{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Batch Normalization\n",
    "One way to make deep networks easier to train is to use more sophisticated optimization procedures such as SGD+momentum, RMSProp, or Adam. Another strategy is to change the architecture of the network to make it easier to train. \n",
    "One idea along these lines is batch normalization which was proposed by [1] in 2015.\n",
    "\n",
    "The idea is relatively straightforward. Machine learning methods tend to work better when their input data consists of uncorrelated features with zero mean and unit variance. When training a neural network, we can preprocess the data before feeding it to the network to explicitly decorrelate its features; this will ensure that the first layer of the network sees data that follows a nice distribution. However, even if we preprocess the input data, the activations at deeper layers of the network will likely no longer be decorrelated and will no longer have zero mean or unit variance since they are output from earlier layers in the network. Even worse, during the training process the distribution of features at each layer of the network will shift as the weights of each layer are updated.\n",
    "\n",
    "The authors of [1] hypothesize that the shifting distribution of features inside deep neural networks may make training deep networks more difficult. To overcome this problem, [1] proposes to insert batch normalization layers into the network. At training time, a batch normalization layer uses a minibatch of data to estimate the mean and standard deviation of each feature. These estimated means and standard deviations are then used to center and normalize the features of the minibatch. A running average of these means and standard deviations is kept during training, and at test time these running averages are used to center and normalize features.\n",
    "\n",
    "It is possible that this normalization strategy could reduce the representational power of the network, since it may sometimes be optimal for certain layers to have features that are not zero-mean or unit variance. To this end, the batch normalization layer includes learnable shift and scale parameters for each feature dimension.\n",
    "\n",
    "[1] [Sergey Ioffe and Christian Szegedy, \"Batch Normalization: Accelerating Deep Network Training by Reducing\n",
    "Internal Covariate Shift\", ICML 2015.](https://arxiv.org/abs/1502.03167)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "# As usual, a bit of setup\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "    \"\"\" returns relative error \"\"\"\n",
    "    return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))\n",
    "\n",
    "def print_mean_std(x,axis=0):\n",
    "    print('  means: ', x.mean(axis=axis))\n",
    "    print('  stds:  ', x.std(axis=axis))\n",
    "    print() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train:  (49000, 3, 32, 32)\n",
      "y_train:  (49000,)\n",
      "X_val:  (1000, 3, 32, 32)\n",
      "y_val:  (1000,)\n",
      "X_test:  (1000, 3, 32, 32)\n",
      "y_test:  (1000,)\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in data.items():\n",
    "  print('%s: ' % k, v.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Batch normalization: forward\n",
    "In the file `cs231n/layers.py`, implement the batch normalization forward pass in the function `batchnorm_forward`. Once you have done so, run the following to test your implementation.\n",
    "\n",
    "Referencing the paper linked to above in [1] may be helpful!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before batch normalization:\n",
      "  means:  [ -2.3814598  -13.18038246   1.91780462]\n",
      "  stds:   [27.18502186 34.21455511 37.68611762]\n",
      "\n",
      "After batch normalization (gamma=1, beta=0)\n",
      "  means:  [5.32907052e-17 7.04991621e-17 1.85962357e-17]\n",
      "  stds:   [0.99999999 1.         1.        ]\n",
      "\n",
      "After batch normalization (gamma= [1. 2. 3.] , beta= [11. 12. 13.] )\n",
      "  means:  [11. 12. 13.]\n",
      "  stds:   [0.99999999 1.99999999 2.99999999]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Check the training-time forward pass by checking means and variances\n",
    "# of features both before and after batch normalization   \n",
    "\n",
    "# Simulate the forward pass for a two-layer network\n",
    "np.random.seed(231)\n",
    "N, D1, D2, D3 = 200, 50, 60, 3\n",
    "X = np.random.randn(N, D1)\n",
    "W1 = np.random.randn(D1, D2)\n",
    "W2 = np.random.randn(D2, D3)\n",
    "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "\n",
    "print('Before batch normalization:')\n",
    "print_mean_std(a,axis=0)\n",
    "\n",
    "gamma = np.ones((D3,))\n",
    "beta = np.zeros((D3,))\n",
    "# Means should be close to zero and stds close to one\n",
    "print('After batch normalization (gamma=1, beta=0)')\n",
    "a_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print_mean_std(a_norm,axis=0)\n",
    "\n",
    "gamma = np.asarray([1.0, 2.0, 3.0])\n",
    "beta = np.asarray([11.0, 12.0, 13.0])\n",
    "# Now means should be close to beta and stds close to gamma\n",
    "print('After batch normalization (gamma=', gamma, ', beta=', beta, ')')\n",
    "a_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print_mean_std(a_norm,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "After batch normalization (test-time):\n",
      "  means:  [-0.03927354 -0.04349152 -0.10452688]\n",
      "  stds:   [1.01531428 1.01238373 0.97819988]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Check the test-time forward pass by running the training-time\n",
    "# forward pass many times to warm up the running averages, and then\n",
    "# checking the means and variances of activations after a test-time\n",
    "# forward pass.\n",
    "\n",
    "np.random.seed(231)\n",
    "N, D1, D2, D3 = 200, 50, 60, 3\n",
    "W1 = np.random.randn(D1, D2)\n",
    "W2 = np.random.randn(D2, D3)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "gamma = np.ones(D3)\n",
    "beta = np.zeros(D3)\n",
    "\n",
    "for t in range(50):\n",
    "  X = np.random.randn(N, D1)\n",
    "  a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "  batchnorm_forward(a, gamma, beta, bn_param)\n",
    "\n",
    "bn_param['mode'] = 'test'\n",
    "X = np.random.randn(N, D1)\n",
    "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "a_norm, _ = batchnorm_forward(a, gamma, beta, bn_param)\n",
    "\n",
    "# Means should be close to zero and stds close to one, but will be\n",
    "# noisier than training-time forward passes.\n",
    "print('After batch normalization (test-time):')\n",
    "print_mean_std(a_norm,axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Batch normalization: backward\n",
    "Now implement the backward pass for batch normalization in the function `batchnorm_backward`.\n",
    "\n",
    "To derive the backward pass you should write out the computation graph for batch normalization and backprop through each of the intermediate nodes. Some intermediates may have multiple outgoing branches; make sure to sum gradients across these branches in the backward pass.\n",
    "\n",
    "Once you have finished, run the following to numerically check your backward pass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx error:  1.702920153919555e-09\n",
      "dgamma error:  7.420414216247087e-13\n",
      "dbeta error:  2.8795057655839487e-12\n"
     ]
    }
   ],
   "source": [
    "# Gradient check batchnorm backward pass\n",
    "np.random.seed(231)\n",
    "N, D = 4, 5\n",
    "x = 5 * np.random.randn(N, D) + 12\n",
    "gamma = np.random.randn(D)\n",
    "beta = np.random.randn(D)\n",
    "dout = np.random.randn(N, D)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "fx = lambda x: batchnorm_forward(x, gamma, beta, bn_param)[0]\n",
    "fg = lambda a: batchnorm_forward(x, a, beta, bn_param)[0]\n",
    "fb = lambda b: batchnorm_forward(x, gamma, b, bn_param)[0]\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(fx, x, dout)\n",
    "da_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\n",
    "db_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n",
    "\n",
    "_, cache = batchnorm_forward(x, gamma, beta, bn_param)\n",
    "dx, dgamma, dbeta = batchnorm_backward(dout, cache)\n",
    "#You should expect to see relative errors between 1e-13 and 1e-8\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dgamma error: ', rel_error(da_num, dgamma))\n",
    "print('dbeta error: ', rel_error(db_num, dbeta))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Batch normalization: alternative backward\n",
    "In class we talked about two different implementations for the sigmoid backward pass. One strategy is to write out a computation graph composed of simple operations and backprop through all intermediate values. Another strategy is to work out the derivatives on paper. For example, you can derive a very simple formula for the sigmoid function's backward pass by simplifying gradients on paper.\n",
    "\n",
    "Surprisingly, it turns out that you can do a similar simplification for the batch normalization backward pass too!  \n",
    "\n",
    "In the forward pass, given a set of inputs $X=\\begin{bmatrix}x_1\\\\x_2\\\\...\\\\x_N\\end{bmatrix}$, \n",
    "\n",
    "we first calculate the mean $\\mu$ and variance $v$.\n",
    "With $\\mu$ and $v$ calculated, we can calculate the standard deviation $\\sigma$  and normalized data $Y$.\n",
    "The equations and graph illustration below describe the computation ($y_i$ is the i-th element of the vector $Y$).\n",
    "\n",
    "\\begin{align}\n",
    "& \\mu=\\frac{1}{N}\\sum_{k=1}^N x_k  &  v=\\frac{1}{N}\\sum_{k=1}^N (x_k-\\mu)^2 \\\\\n",
    "& \\sigma=\\sqrt{v+\\epsilon}         &  y_i=\\frac{x_i-\\mu}{\\sigma}\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"notebook_images/batchnorm_graph.png\" width=691 height=202>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "The meat of our problem during backpropagation is to compute $\\frac{\\partial L}{\\partial X}$, given the upstream gradient we receive, $\\frac{\\partial L}{\\partial Y}.$ To do this, recall the chain rule in calculus gives us $\\frac{\\partial L}{\\partial X} = \\frac{\\partial L}{\\partial Y} \\cdot \\frac{\\partial Y}{\\partial X}$.\n",
    "\n",
    "The unknown/hart part is $\\frac{\\partial Y}{\\partial X}$. We can find this by first deriving step-by-step our local gradients at \n",
    "$\\frac{\\partial v}{\\partial X}$, $\\frac{\\partial \\mu}{\\partial X}$,\n",
    "$\\frac{\\partial \\sigma}{\\partial v}$, \n",
    "$\\frac{\\partial Y}{\\partial \\sigma}$, and $\\frac{\\partial Y}{\\partial \\mu}$,\n",
    "and then use the chain rule to compose these gradients (which appear in the form of vectors!) appropriately to compute $\\frac{\\partial Y}{\\partial X}$.\n",
    "\n",
    "If it's challenging to directly reason about the gradients over $X$ and $Y$ which require matrix multiplication, try reasoning about the gradients in terms of individual elements $x_i$ and $y_i$ first: in that case, you will need to come up with the derivations for $\\frac{\\partial L}{\\partial x_i}$, by relying on the Chain Rule to first calculate the intermediate $\\frac{\\partial \\mu}{\\partial x_i}, \\frac{\\partial v}{\\partial x_i}, \\frac{\\partial \\sigma}{\\partial x_i},$ then assemble these pieces to calculate $\\frac{\\partial y_i}{\\partial x_i}$. \n",
    "\n",
    "You should make sure each of the intermediary gradient derivations are all as simplified as possible, for ease of implementation. \n",
    "\n",
    "After doing so, implement the simplified batch normalization backward pass in the function `batchnorm_backward_alt` and compare the two implementations by running the following. Your two implementations should compute nearly identical results, but the alternative implementation should be a bit faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx difference:  1.2693239795334417e-12\n",
      "dgamma difference:  0.0\n",
      "dbeta difference:  0.0\n",
      "speedup: 1.68x\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D = 100, 500\n",
    "x = 5 * np.random.randn(N, D) + 12\n",
    "gamma = np.random.randn(D)\n",
    "beta = np.random.randn(D)\n",
    "dout = np.random.randn(N, D)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "out, cache = batchnorm_forward(x, gamma, beta, bn_param)\n",
    "\n",
    "t1 = time.time()\n",
    "dx1, dgamma1, dbeta1 = batchnorm_backward(dout, cache)\n",
    "t2 = time.time()\n",
    "dx2, dgamma2, dbeta2 = batchnorm_backward_alt(dout, cache)\n",
    "t3 = time.time()\n",
    "\n",
    "print('dx difference: ', rel_error(dx1, dx2))\n",
    "print('dgamma difference: ', rel_error(dgamma1, dgamma2))\n",
    "print('dbeta difference: ', rel_error(dbeta1, dbeta2))\n",
    "print('speedup: %.2fx' % ((t2 - t1) / (t3 - t2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fully Connected Nets with Batch Normalization\n",
    "Now that you have a working implementation for batch normalization, go back to your `FullyConnectedNet` in the file `cs231n/classifiers/fc_net.py`. Modify your implementation to add batch normalization.\n",
    "\n",
    "Concretely, when the `normalization` flag is set to `\"batchnorm\"` in the constructor, you should insert a batch normalization layer before each ReLU nonlinearity. The outputs from the last layer of the network should not be normalized. Once you are done, run the following to gradient-check your implementation.\n",
    "\n",
    "HINT: You might find it useful to define an additional helper layer similar to those in the file `cs231n/layer_utils.py`. If you decide to do so, do it in the file `cs231n/classifiers/fc_net.py`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.2611955101340957\n",
      "W1 relative error: 1.10e-04\n",
      "W2 relative error: 2.85e-06\n",
      "W3 relative error: 4.05e-10\n",
      "b1 relative error: 2.78e-09\n",
      "b2 relative error: 2.22e-08\n",
      "b3 relative error: 1.01e-10\n",
      "beta1 relative error: 7.33e-09\n",
      "beta2 relative error: 1.89e-09\n",
      "gamma1 relative error: 6.96e-09\n",
      "gamma2 relative error: 1.96e-09\n",
      "\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  6.996533220108303\n",
      "W1 relative error: 1.98e-06\n",
      "W2 relative error: 2.28e-06\n",
      "W3 relative error: 1.11e-08\n",
      "b1 relative error: 5.55e-09\n",
      "b2 relative error: 2.22e-08\n",
      "b3 relative error: 1.73e-10\n",
      "beta1 relative error: 6.65e-09\n",
      "beta2 relative error: 3.48e-09\n",
      "gamma1 relative error: 8.80e-09\n",
      "gamma2 relative error: 5.28e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "# You should expect losses between 1e-4~1e-10 for W, \n",
    "# losses between 1e-08~1e-10 for b,\n",
    "# and losses between 1e-08~1e-09 for beta and gammas.\n",
    "for reg in [0, 3.14]:\n",
    "  print('Running check with reg = ', reg)\n",
    "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64,\n",
    "                            normalization='batchnorm')\n",
    "\n",
    "  loss, grads = model.loss(X, y)\n",
    "  print('Initial loss: ', loss)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))\n",
    "  if reg == 0: print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batchnorm for deep networks\n",
    "Run the following to train a six-layer network on a subset of 1000 training examples both with and without batch normalization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solver with batch norm:\n",
      "(Iteration 1 / 200) loss: 2.340974\n",
      "(Epoch 0 / 10) train acc: 0.107000; val_acc: 0.115000\n",
      "(Epoch 1 / 10) train acc: 0.314000; val_acc: 0.266000\n",
      "(Iteration 21 / 200) loss: 2.039365\n",
      "(Epoch 2 / 10) train acc: 0.385000; val_acc: 0.278000\n",
      "(Iteration 41 / 200) loss: 2.041103\n",
      "(Epoch 3 / 10) train acc: 0.493000; val_acc: 0.308000\n",
      "(Iteration 61 / 200) loss: 1.753903\n",
      "(Epoch 4 / 10) train acc: 0.533000; val_acc: 0.309000\n",
      "(Iteration 81 / 200) loss: 1.246167\n",
      "(Epoch 5 / 10) train acc: 0.587000; val_acc: 0.319000\n",
      "(Iteration 101 / 200) loss: 1.320490\n",
      "(Epoch 6 / 10) train acc: 0.622000; val_acc: 0.329000\n",
      "(Iteration 121 / 200) loss: 1.198438\n",
      "(Epoch 7 / 10) train acc: 0.689000; val_acc: 0.339000\n",
      "(Iteration 141 / 200) loss: 1.072050\n",
      "(Epoch 8 / 10) train acc: 0.724000; val_acc: 0.309000\n",
      "(Iteration 161 / 200) loss: 0.760442\n",
      "(Epoch 9 / 10) train acc: 0.773000; val_acc: 0.318000\n",
      "(Iteration 181 / 200) loss: 0.825195\n",
      "(Epoch 10 / 10) train acc: 0.801000; val_acc: 0.357000\n",
      "\n",
      "Solver without batch norm:\n",
      "(Iteration 1 / 200) loss: 2.302332\n",
      "(Epoch 0 / 10) train acc: 0.129000; val_acc: 0.131000\n",
      "(Epoch 1 / 10) train acc: 0.283000; val_acc: 0.250000\n",
      "(Iteration 21 / 200) loss: 2.041970\n",
      "(Epoch 2 / 10) train acc: 0.316000; val_acc: 0.277000\n",
      "(Iteration 41 / 200) loss: 1.900473\n",
      "(Epoch 3 / 10) train acc: 0.373000; val_acc: 0.282000\n",
      "(Iteration 61 / 200) loss: 1.713156\n",
      "(Epoch 4 / 10) train acc: 0.390000; val_acc: 0.310000\n",
      "(Iteration 81 / 200) loss: 1.662208\n",
      "(Epoch 5 / 10) train acc: 0.434000; val_acc: 0.300000\n",
      "(Iteration 101 / 200) loss: 1.696062\n",
      "(Epoch 6 / 10) train acc: 0.536000; val_acc: 0.346000\n",
      "(Iteration 121 / 200) loss: 1.550785\n",
      "(Epoch 7 / 10) train acc: 0.530000; val_acc: 0.310000\n",
      "(Iteration 141 / 200) loss: 1.436307\n",
      "(Epoch 8 / 10) train acc: 0.622000; val_acc: 0.342000\n",
      "(Iteration 161 / 200) loss: 1.000868\n",
      "(Epoch 9 / 10) train acc: 0.654000; val_acc: 0.328000\n",
      "(Iteration 181 / 200) loss: 0.925455\n",
      "(Epoch 10 / 10) train acc: 0.726000; val_acc: 0.335000\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "# Try training a very deep net with batchnorm\n",
    "hidden_dims = [100, 100, 100, 100, 100]\n",
    "\n",
    "num_train = 1000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = 2e-2\n",
    "bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization='batchnorm')\n",
    "model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n",
    "\n",
    "print('Solver with batch norm:')\n",
    "bn_solver = Solver(bn_model, small_data,\n",
    "                num_epochs=10, batch_size=50,\n",
    "                update_rule='adam',\n",
    "                optim_config={\n",
    "                  'learning_rate': 1e-3,\n",
    "                },\n",
    "                verbose=True,print_every=20)\n",
    "bn_solver.train()\n",
    "\n",
    "print('\\nSolver without batch norm:')\n",
    "solver = Solver(model, small_data,\n",
    "                num_epochs=10, batch_size=50,\n",
    "                update_rule='adam',\n",
    "                optim_config={\n",
    "                  'learning_rate': 1e-3,\n",
    "                },\n",
    "                verbose=True, print_every=20)\n",
    "solver.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the following to visualize the results from two networks trained above. You should find that using batch normalization helps the network to converge much faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": [
     "pdf-ignore-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3AAAANsCAYAAAAa/ko3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdf5QU9Zkv/vfT80N6NDIJA0tmBgNxvbouElEwbmY2iXj8EVEkxgzGmB9310t2s2r0ZCGjx4sTvkkcId+gJHGNl81JchITJxFxFLPolfwaEiPgIBIjayK6zIwsDDIYmMb50Z/7R3XPVFfXz66q7qru9+scD0x1dXdVdYfUM8/zeR5RSoGIiIiIiIiiL1HqAyAiIiIiIiJ3GMARERERERHFBAM4IiIiIiKimGAAR0REREREFBMM4IiIiIiIiGKCARwREREREVFMMIAjIqKyISJVInJMRE4Lct8CjuMrIvK9oF+XiIioutQHQERElUtEjul+rAPwNoDxzM+fU0r9yMvrKaXGAZwS9L5ERERRwQCOiIhKRik1EUCJyGsAblRK/V+r/UWkWik1VoxjIyIiiiKWUBIRUWRlShEfFpEfi8hfANwgIn8nIs+KyJCIvCEi60WkJrN/tYgoEZmd+fmHmcd/LiJ/EZHficgcr/tmHv+IiPyniBwVkW+KyDYR+azL81gqIn/IHPNWETlT99gdIjIgIm+JyMsi8uHM9gtF5PnM9v8WkbUBXFIiIoo5BnBERBR1HwXwEICpAB4GMAbgCwAaALQAuBzA52yefz2A/w3gXQD+C8D/53VfEZkBoAvAisz77gNwgZuDF5G/AfBDADcDmA7g/wJ4XERqRORvM8d+nlLqVAAfybwvAHwTwNrM9r8G8DM370dEROWNARwREUVdj1LqcaVUWimVUkptV0r9Xik1ppR6FcCDAD5k8/yfKaV2KKVGAfwIwLkF7HslgF1Kqccyj60DMOjy+K8D0K2U2pp5bieAUwG8H1owOgXA32bKQ/dlzgkARgGcISLTlFJ/UUr93uX7ERFRGWMAR0REUbdf/4OInCUim0XkgIi8BWA1tKyYlQO6vw/DvnGJ1b6N+uNQSikAfS6OPfvc13XPTWee26SU2gvgi9DO4WCmVHRmZtf/CeBsAHtF5DkRucLl+xERURljAEdERFGnDD9/B8AeAH+dKS9cBUBCPoY3ADRnfxARAdDk8rkDAN6je24i81r9AKCU+qFSqgXAHABVAO7ObN+rlLoOwAwA/z+AR0Rkiv9TISKiOGMAR0REcfMOAEcBHM+sL7Nb/xaUJwCcJyJXiUg1tDV4010+twvAEhH5cKbZygoAfwHwexH5GxG5SEROApDK/DcOACLyKRFpyGTsjkILZNPBnhYREcUNAzgiIoqbLwL4DLQg6DvQGpuESin13wCWAfgGgMMATgfQC21undNz/wDteP8NwCFoTVeWZNbDnQRgDbT1dAcAvBPAnZmnXgHgj5num18HsEwpNRLgaRERUQyJVsZPREREbolIFbTSyGuVUr8p9fEQEVHlYAaOiIjIBRG5XESmZsod/ze0DpLPlfiwiIiowjCAIyIicqcVwKvQyh0vB7BUKeVYQklERBQkllASERERERHFBDNwREREREREMVFd6gMw09DQoGbPnl3qwyAiIiIiIiqJnTt3Diql8kbWRDKAmz17Nnbs2FHqwyAiIiIiIioJEXndbDtLKImIiIiIiGKCARwREREREVFMMIAjIiIiIiKKCQZwREREREREMcEAjoiIiIiIKCYYwBEREREREcVEJMcIRM2m3n6s3bIXA0MpNNYnseKyM7F0flOpD4uIiIiIiCoMAzgHm3r7cfvGF5EaHQcA9A+lcPvGFwGAQRwRERERERUVSygdrN2ydyJ4y0qNjmPtlr0lOiIiIiIiIqpUDOAcDAylPG0nIiIiIiIKCwM4B431SdPtCkBL51Zs6u0v7gEREREREVHF4ho4BysuOxM9j96PW/ETNMogjqhTIALU4xgGhhvwq0fnY/ipPahLHQCmNgMXrwLmtZX6sImIiIiIqAyJUqrUx5BnwYIFaseOHaU+DM3uLow9djOqx0+YPqwUIDL587hUo2rKqUDqiBbQnXEp8MpTwNE+858Z8BERERERkYGI7FRKLcjbzgDOwbq5wNH94b1+TRK4an0wQdzuLuCZ1QwOiYiIiIhiziqA4xo4J0f7wn390ZQWdPm1uwt4/JZMsKm0Px+/RdtORERERERlgQGck6nN4b+H2yBxd5eWEeyo1/7UB2fPrNaCQb2ggkMiIiIiIooEBnBOLl6llTlaCKQC1U2Q6JRhswoCrbbbBYNERERERBRJjgGciMwSkV+IyB9F5A8i8gWTfT4pIrsz//1WRN6ne+w1EXlRRHaJSEQWtnkwr01bozZ1FgABku/S/oNgOPluPKQuQV+6AWklOJw+BSPKY2PPmqQWJAL+MmxWQaDZdpZbEhERERHFkptoYwzAF5VSz4vIOwDsFJGnlVIv6fbZB+BDSqkjIvIRAA8CeL/u8YuUUoPBHXaRzWszbQZSB+Dk3n4s27IXA0MpNNYn8YUZvfjgf/0bZqhBHJQGHH/PxTh9aJt1F8ozLtWCsI3/C4BAmzCHyaAq+/5OGbaLV2n764M8fXCoZxcMsukJEREREVFkOQZwSqk3ALyR+ftfROSPAJoAvKTb57e6pzwLoAgLx6Jh6fwmLJ3fBADY1NuP2zeOIDV638TjyVercPc1qyb2yZHNhE0EU4Z6TH1QNbXZvBumJLSM3dRm4H3XuxtR4LXckoiIiIiIIsHTGjgRmQ1gPoDf2+z2jwB+rvtZAXhKRHaKyHKb114uIjtEZMehQ4e8HFZkrN2yF6nR8ZxtqdFxrN2y1/wJZpkwI32GzWwtnhrHRBnkCw9p+3UMAbftsc6meSm3JCIiIiKiyHAdwInIKQAeAXCrUuoti30ughbAfUm3uUUpdR6AjwD4FxH5oNlzlVIPKqUWKKUWTJ8+3fUJRMnAkHkwpt++qbcfLZ1bMad9M9IuMl7DyZnaX4xr8aQqf2e3XSfNgkGrcksiIiIiIooMVx03RKQGWvD2I6XURot95gHYAOAjSqnD2e1KqYHMnwdF5FEAFwD4td8Dj6LG+iT6TYK4hAjmtG/G1GQNjo+MYXRcK5UcSE9Dc8J6aeCwqsWa0WXoyG7Qr8XrqDd/kpsyyOxrcOg3EREREVGsuOlCKQD+HcAflVLfsNjnNAAbAXxKKfWfuu0nZxqfQEROBnApgD1BHHgUrbjsTCRr8jNj40pBARhKjU4EbwCwZqwNw6o2Z9+00kYT9KUb0D56I75/7ALzN/NbBjmvTSuzdCq3JCIiIiKiyHCTgWsB8CkAL4rIrsy2OwCcBgBKqQcArAIwDcD9WryHMaXUAgB/BeDRzLZqAA8ppf4j0DOIkGyjkrWZrpQJEYzbDIrrTrcCo8DK6i40ymEMqGlYM9ambc9oqreYQeel6yQREREREZUFUYFMog7WggUL1I4d8RsZZzSnfbOxr6QnyZoq3H3NOeYdLAGtiyXLIImIiIiIyo6I7MwkxXJ4nDpNXlitiXOjqT6Je89+BQt/+a/AY1qAtv30m3HrS2dMzJxbcVkLlt5WthWpRERERERk4GmMAHljtiauJiF4Z10NBEB9sgY1VZLzeLKmCvcuOxfbrhjEwhfvysx+08YEzN15J85/62koAP1DKdy+8UVs6u23PoDdXcC6uVrDk3VztZ+JiIiIiCi2mIELkXFNnJY1OzOnJHJTb7/54+vyZ8QlZQQrq7vQPaKtkcvOmHM1JPzofu1ngGWWREREREQxxQAuZEvnN1mvYbN73GIcQKMczvnZOGMuGwz+bsodmAlD+WZ2TpyLAM4YWN579itY+Odvcr0dEREREVEJsYQyqizGAQyoaTk/N2a6VG7q7cftG19E/1AKCsAMdcj8dY/udyynNL7W+W89jbk778wp58Tjt7Akk4iIiIioyJiBi6jtp9+MuTvvRFJGJrYNq1qsGZvMeiVrqrDisjMBaGWaqdHxiccGVAOaxWJI+NH9GHvsZnyl+w/4/rEL8jJsF6IBl4x/HN3QSjVXVnflHAcAT9k8IiIiIiIKBjNwEXXrS2fgS6M3oi/dgLSSicHem9XfQ6B1qdSPGBgwdLs0GxKuVz1+AjeO/NA0wzYTh9BZswFLEj0AgEbLQNC8zJOIiIiIiMLBDFxEDQyl0I/WiYYlWQKFfZ2LAWilji2dW02HhmeHhN9R+1PMhHk5ZXY9nVmGrU7XMMUym2dR5klEREREROFgBi6ismvbrLYb16mNmwxkf7rqQ3j26l8BU2eZvlZ2PZ1Vhi0b4K0Za0PKmM2rSWqNTIiIiIiIqGgYwEWU2Qw5uzVvWVUi+SWWF6/CWNWUnP306+kGVIPpMaRF8OpJ1+OO2p9i17TFOIDpSCvBAUzH9nO+zPVvRERERERFxhLKiHKaIWdc85aVVpMlllmbxlvQM3ojbsVP0CiHMaCmYc1Ym1ZmCS3Ddk/NhrwyymqkAQFm4hCmHt6ML43eOPGc5PYq3D2r33ZEQhRYztkjIiIiIoohBnARZjdDrrE+iX6TIM6s9HLtlr3oH/kAfoYP5GyvEkFaKew89RLsOXv25Jw3SQAqN7vnaYh4RGTLTLOZyv6hFG7f+CIARPq4iYiIiIisMICLqRWXnZkTnAC5JZZ67rJ1iwB8TvtrR73p/nZDxItmd5c2vsDFQHGzMtM4BJ5ERERERFYYwMWUU4klMFk+mN/eRGPVKAVTmzMjBXJlm54sSfRgZXUXGhOHgXX2QZRv+oAt+U5g5Bgwnin1zA4UB0zf3yrALEngSUREREQUAAZwMWZXYmksHzSyytYB0AKyx2/RhnVnpDJNT5YketBZswF14i6I8mV3V+5xpN7M38dmoLiXMlMiIiIiojhgF8oyZdWlEsgfAp5nXhtw1frM+AEBps7CnvO/gp2nXoKV1V2TwVtWNogK2jOrc4JISxYDxZ06eVKE7e4C1s3VynnXzdV+JiIiIiJm4MqVVZmgANjWvihve363xhYsvW3PxOMLAWxbAqDjcN5zAeQEUdu7v4NZz6/FDHUIB2U69p+3AguXfM77SVgEZnn0A8V1JZdLpzbjnPe24OTXn8k9lvmXm7+Oh/V1QWO3TB1j5jXMLC8RERFRzDADV6acBoHrGYeCZ7s1burtz38BfbBksn1793cwd+edmIlDSGRGEMzdeSe2d3/H+0lYvZeefqB49sb/6H4ACji6H6e//pOcY1n44l3m2RyT5+LxW4qS+fF0/SuBWeY1rCwvERERUcwwgCtTXsoH7bo15rl4lRY06emCqFnPr82bJ5eUEcx6fq33kzB7r0QNkHwXsqWduGr9ZFbGTcmlVSBQwqDB0/WvBFaZV7cZWSIiIqIyxhLKMuWmS2WWp26N+mApW2p4xqXazxuX46+U0uo0DWaoQeuDtSpdNHsvu7JGtzf4ZvuVMGhgt0wDiy6orjKyRERERGXOMYATkVkAfgBgJoA0gAeVUvcZ9hEA9wG4AsAwgM8qpZ7PPHZ55rEqABuUUp2BngFZsutSqee5W6M+uDKsVxKT4A0ADkoDZpo94LTeSf9eTqxu/M32c/vcIgQN7JZpYNIFNadUloiIiKiCuSmhHAPwRaXU3wC4EMC/iMjZhn0+AuCMzH/LAfwbAIhIFYBvZx4/G8AnTJ5LJea1W+Om3n60dG7FnPbNOLDxDseyxZSqxf7zVpg/GGTpolnJpZFVIOBQGhomdss0MOmCmlMqS0RERFTBHDNwSqk3ALyR+ftfROSPAJoAvKTb7WoAP1BKKQDPiki9iLwbwGwAf1JKvQoAIvKTzL7651KJeSm3NM6Xm6EOmZZMKgBKCQ5KA/afb+hCqS+ZtBoz7rJ0Mbd7YwPuPefLWPjnb+aWd77ylHMJptdyzQB5uf4Vw0vmlYiIiKiCeFoDJyKzAcwH8HvDQ00A9PVnfZltZtvf7/UgKXxuyy2NDTcGVAOaJX99m0ydBbltD2YCuaWTxpJJKy5KFzf19qPn0fvxMH6CxpMGMTDcgHt3XIf+j24pLPgpYdDg9voTERERUWVz3YVSRE4B8AiAW5VSbxkfNnmKstlu9vrLRWSHiOw4dOiQ28OiIjM21lgz1oZhVZu7k13poZtOkS5LF3dtfhCr5UE0JwaREKA5MYjV8iB2bX7Q8blERERERHHkKoATkRpowduPlFIbTXbpAzBL93MzgAGb7XmUUg8qpRYopRZMnz7dzWFRCRgba3SnW9E+eiMOYDpcrVeyKI1UANJKMIAG3D76vzDnoZPR0rnVdhbajSM/RJ1hZEGdjODGkR96OaVw7O4C1s0FOuq1P73Mk/PzXPKP15+IiIgizE0XSgHw7wD+qJT6hsVu3QBuyqxxez+Ao0qpN0TkEIAzRGQOgH4A1wG4PphDp1JYcdmZOWvgAODpqg9h0dU3WZYA6tep/W5KA2YiP8Pan25A68j63G2ZgdYATF+7MXHY9P2stuexGl/gl1NnzbCeS/7x+hMREVHEucnAtQD4FIBFIrIr898VIvJPIvJPmX2eBPAqgD8B+D8APg8ASqkxADcB2ALgjwC6lFJ/CPokqHiWzm/C3decg6b6JARAU30Sd19zjm3wdvvGF9E/lIIC8LWRjyNlKLkcVrVYM2Z+c2w30PpE0nQwgeX2HNkb9aP7AajJG/Ugsi1+OmuWcKA4gdefiIiIIs9NF8oemK9l0++jAPyLxWNPQgvwqEwYG25kxwqYdVA0Nj3pTrcCo8CXarrwbhzGgJqGNWNt2nYLVgOt6z6yGmOP3Yzq8RMT28aqpqDuIz4DJb+ZFj9DwUs4UJzA609ERESR56kLJZGRcayAsexxYCiFJYkerKzuQqMMYkA1YM1YG1reXm/3sjnsBopXAzllkNVuyyDDvFH3MxS8hAPFCbz+VBxhlW8TEVFFcN2FksiMMcMG5JY9fuaU59BZsyGnU2RnzQYsSfSYvt6SRA96am/Bqyddj57aW3Bt7W/tB1rPawNu2wN0DGl/ur0JsrohD+JG3c9Q8BIOFCfw+lthY5fghFm+TUREFYEBHPliVd6Y3b6y5mHTTpErq/NvVq5O9OCe2vxgb2nVtuAPPMwb9XltWifOqbPgqjNnUM8l/8yu//uu17IllRq8MOAIFtdZEhGRTyyhJF8a65PoNwnismWPdakD5s+T3E6RTfVJ3HfS48DR3GCvevxEMOvSjLKvF1YZk9eh4CypslfM66P/7NiVMtz1opWI6yyJiMgnZuDIlxWXnYlkTVXOtmRN1WTZo0VJ4oCalr9/sW9sCi2/DBozHPZKeX3KNVvipSSSAUewwizfJiKiisAAjnxxHCtgUqo4VjUFG2pvyN+/Um9syjVICEoQ16fQNVzlGLx4DYgr9X+XYeE6SyIi8okllOSbcaxADpNSxeqLV6FjXhs6jPtevCq3XA3Iu7HRDwU3jiyIrXIMEoLk9/r4KYP025UyiqWxXksiXfzvkjwwK98+41Lt543Lo/M9ISKiyGIAR+Fzux7MYV2a08iC7D6BBXh2N99B3pg7BQlRDAKC4Pa8/AZRftZw+Qleorp+zmtAHPZ60UrEdZZEROSDaDO4o2XBggVqx44dpT4MipiWzq2mDVOa6pPY1r4oL8ADtPV1OSWdNvTB32dOeQ53qgdyhoSjJql1KATMb+oL7RZpvIEzvJfZsPLqq78Z75s7u3M2npeXfc101AMw+3dOtPWPbo61kOBl3VyLwHOWtuayVKJ6XJWKnwcREVkQkZ1KqQXG7czAUWw4jSywm0lnFsDpA7apyRocHxnD6Lh2o3/jyA9RnTiR+wT9uiu/XfmMQcH7rgdeeSovSBi+5yzUjeceR/X4CQz/fBXqCg0Wo5BJ8ZIV85sB8pvB89pRNCuqpbEsiYyWqH5PiIgoshjAUWw4jSxwCvD0jNm6odRo7mvKoPlB2N1UHd2vZXucAgyzkqkXHjLNKE2xGMNgtd1W2KVaXoLDQsr4Cj3GUgUsfgPHsLAkMlqi+j0hIqLIYhdKig2nkQXZQM5oYruuE+GFj30Il4z/yvK9BlSD+QNTmx1urFx09fPQVXEgPS1vm912W2F2u4xyZ0On4eiFdqh0EuVug1EZoUHR/p4QEVEkMYCj2HAaWWAb4BkCjJk4hM6aDViS6DF9rzVjbRhWtbkbszdVZjdcRnaBkYfs04baG/KOY1jVYkPtDfbv7/N9PfMaHAZ90+oUhFkFLGHOmHMKHIkAfk+IiMgzllBSpJl1ldzWvsh032wgZ9qFcl1+gFEnI1hZ3YXukda81+pOt6JWJbC67hHUpQ6Yl5llS9BMG2TAOjDyUDJ17uLlWPXoGG5VP0GjHMaAmoZ7cR1aFy83f207YZZqlbKzoZ/SUD8dKt3wU/pJlYPfEyIi8oABHEWWm7EBRpYz6SwCiUY5PPH3moTglCnVGBoeRWN9Eq2XfR518786uXM2y3O0D8PJmVgzugzfP3EBfjflC5iJQ/kvbhUYOazJMgatF513HZa9fLH/0QhBrwXTr3mTBKDG8/exCw6Dumn1E4QFMWOOa8koaPxeERGRDQZwFFleu0rassg+HZQGCOAcGBmyPHWpN7BS3Y83EyP42sjHcU/NBiRlZHJ/u8DIJvtkFrQ+srPf9SgEW2FmvcyCN4fgMLCZfX6CMD9ZyUqe38UAIzyV/L0iIiJXOAeOImtO+2ar6V3Y17nY24sVMEtMH2BYZdn60g1oHVmPJYke3FH7U8zEIDC1GdtPvxm3vnSG5+DEadad63MN++baanaVVAEq7fi+fmf2uToWN3O0/MyYq9T5XX7n8pG9Sv1eERFRHs6Bo9hxGhvgybw2bH/tCGY9vxYz1CAOSgP2n7MCC10GGDPUIS1yNB5LpgSzO92K7hOtEABTpQbHfz+G0XHt2N2UfmZ5GYVgqli/vbfKbqm0q+HYgWZX/ZSG+slKVur8rrDXDVa6Sv1eERGRawzgKLJWXHamaZYmOzbAi029/bh9+3uQGr1v8rW2V+HuWf2mAYMxwBhQDWg2mQ03oHLb+Svkz5QD3AcnBQWtTmvRwri5dlN6aJMJ9B2o6nkMzs2eX9C1idr8rmKVNXoNMFhu6U3UvldERBQ5HCNAkeU0NsALu4yPGWMgYTZWYFjVYs2Y+xtRN8GJ06y7PMY2+GZr0YDgf3vvNAbAoT2/48w+Dzb19uPT29+DC0/ch/e+/SNceOI+fHr7e7Cpt9/za3lS6vld+tEJ98wBHvuXcMYhGHmZ4RfmmIZyVervFRERRR4DOIq0pfObsK19EfZ1Lsa29kUFN/LwmvExBhLd6Va0j96IvnQD0krQl27A7aM3ojudP4LAipvgxHPQalbOZsbqprvQIdZOs6sc5sJ5DlRteA3OA1PK+V3GwCj1JjA+krtPUEPajbwEGGEOjy9XnAtHREQOHEsoReS7AK4EcFApNdfk8RUAPql7vb8BMF0p9aaIvAbgLwDGAYyZLcIjKgavpYlm5Zvd6da8mXFNmeebvbael+DEchSCGTeZNauba7/r5exKDx3K7Gxn9rmgbzBj1uhmSaIHK4e7gI7D4ZbtlWp+l9vAPYx1U17WDXI9V2E4F46IiGy4WQP3PQDfAvADsweVUmsBrAUAEbkKwG1KqTd1u1yklMpfPERURF7X0xkDDKterQNDKaxbdm7eaxtnyhXcIt+J1XoZN90grbIjj/4TsHG5v8DHxTqevEB1d5c2cN0hKDDrYKm3JNGDzpoNqMuOdSjHNuxuA6Cw1k25DTC4nouIiChwjgGcUurXIjLb5et9AsCP/RwQURgKyfjoAwyr9v6N9cmCXjuwGWhWHRjdlFxZdpLMBEZ+Ah+vnSE9ZAPNSib1VlZ3TQZvWeXWJdEqMNKLwrqpoIfHExERkbs5cJkA7gmzEkrdPnUA+gD8dTYDJyL7AByB1pzvO0qpB22evxzAcgA47bTTzn/99dfdnwVRyIKcWxboDDSg8C5/VvOmjAqdP+XluDzMvrKaDwhokx7+POWTSFhNEHQx4qCk3F4zs1lsiRrgpHcAqSPR6vbILpREREQFKcYcuKsAbDOUT7YopQZEZAaAp0XkZaXUr82enAnuHgS0Qd4BHheRb37XbOkFOgMNKHy9jFl2xEyh65W8HJeHtVKN9Umc/9bTWFndhUYZxIBqwJqxNuw89RJt2Pm6mJbtOWUhjYHQ+64HXnkq+oER13MREREFKsgA7joYyieVUgOZPw+KyKMALgBgGsARRZ2n5iI2Ap2B5oexGYXZDDlA295RH26Q4GGt1L1nv4K5OzcgmSmTbJZB3FOzAXvOng1gUXzL9pw6NhqDuxceYndCIiKiChTIGAERmQrgQwAe0207WUTekf07gEsBFFCHRVRegpyBZmZTbz9aOrdiTvtmtHRutZ+HNq9NK1HsGAI++kB+e3ggE9SFPMPLQ2v6hX/+5kTwlpWUESz88ze1H+Laht0uC8l2/MVX6IgNIiKikLkZI/BjAB8G0CAifQDuAlADAEqpBzK7fRTAU0qp47qn/hWAR0Uk+z4PKaX+I7hDJ4onrx0xjewaoBjX1/UPpdDz6P249KlHUJc6YJ9Fc5ORC6sZSNCt6eNYtmeXhYxyO/5yXOPmd8QGERFRiFw1MSm2BQsWqB07dpT6MIiCY7jJ3X76zbj1pTM8r6dzaoBi7JaZ11IfwFjVFFRf/U3nG9GOeiCKzUA8NDwpOj/BjFljkmxH0WdWR/Oc7Y45zoFOlL9jRERUMayamARSQklENrI3uUf3I1uKuPDFu7DtikHs61yMbe2LXK+ts2uAAuSvozNrqV89fgLDP3exHsyq6UdIzUBcl356KLcsKpPP2VPJqV3pZ1TPuVxLO6Oc8SQioooXZBMTIjJjd5PrMUvh1AClsT6Zk4FrlEHT/aekDji/WdDNQGyyU2aln7dvfBEA8oNbL+WWGYHN3bNTwOecf1wtWGqW4SngnPOEUepYroEOB5ATEVGEMYAjCluAN7nGAE2/HchfXzegGtBsEsQNpKfB8VY0iKAhy2FNkefRCh7WuHkKDv3w+Dl7Pi4/6/rCWtMVdqBTqvV1ce1kSkREFR9XBCoAACAASURBVIEllEQhG07O9LTdzorLzkSypipnm74BytL5Tbj7mnPQVJ+EAPj6+DIMq9rc91W12FB7g6v32zTegpa312POiR+h5e312DTe4vmYATiW2oU5WsGp7DQwLkpO9WWiX+x6oTjHBYRX6hhmaaffklQ/zMpZ33e9dr3YlZKIiEqMARxRyNaMmgdRa0aXeX4tY4DWVJ/Ex85vwtoteyfWjgHAtvZF2Ne5GB++9l+wSi1HX7oBaSXoSzdglVqOcxcvd3yvbIaofygFhckMke1YAisO2akwRysUbe6eQzBjvJ7jFg2kQpkHGFapY5gjG0q9vk4/YuPiVdrcvVIEk0RERAYsoSQK2fePXYA3EyNYWd2FRjmMATUNa8ba8PjbF6CjgNfTDxR3KsPT9vs8lm252PP6L89ljXYcSu38jlaw41R2GhiHklOz62km8OMCwi11DGtkQ5TW1wW4jpWIiMgvBnBEIWusT6J7qBXdI60525sCuFF3E2QZA761W/bitod3OQZzgWauHNYUZY8hjEYjYQaHeQzBzKbefqzt3IqBTNZtSaInE8gPYkA1YM1YG7rTk9+L0I7L45quojR9cWIVdEpCK2Ms5pq4KAWTVFzlOOeQiGKPARxRyMIMILwEWV6bZgSauXLREEUfaAYpzODQSB/4TE3W4PjIGEbHtVJJ40y+ZhlEZ80GJMYEj423hBsoeWhIU7SmL07Mgk5gcrh8MYdrsytlZeJAdyKKKA7yJiqCsDIaxsHdWU31SWxrX1TwvtljthsaTrnMrpdeT+0taE7kdwQdTr4bdV96OezDc83r9yRU+uyHJCaDN71iDNcu14HlZI8D3YmoxKwGeTMDR1QEYWWXvGT3vJZEFjNzFSsWJVVOa9ysZvLVuZnJV0RFa/rihr4ktaPefJ9ilDEGOVKD4oOls0QUUQzgiGLMS5BVSEmkl8DTKcvoJwsZiTVZgG1J1cDQybZPtZrJF7UyvKI1ffGq1GWMYTVroegq9XeOiMgCSyiJKoRZiV9NQnDKlGoMDY/6Coycyi39lGOWupRTHzz+bsoXMBOH8neaOgstb683DXyyliR6cE/NBiQza+AAAIka4KR3AKkjpc3q6LKKw8mZWHX8Y/jZyAcmHo5E6SzLGKnY+J0johKzKqHkHDiiCmGcIVefrAEEODI86nvOm9OwbD/DtAt5rn5gdkvn1sJm1yF/dtsMZRK8AcDRPtMh6zUJwTvraiAAdp56Cfac/5XJmWnJdwEiQOpNlHS2mGFgdl3qDXTWbMBnT3luYtZgyYM3INyZcxQ9u7u0NWilHJzO7xwRRRRLKIkqiL4ksqVzK4ZSozmPO815sypldFo35WddldfnOnZR9NAW3Bg82pVBuitnXQTgc9pf183NBG86HmaLBVZWajLjrHr8BDqmPoKOO7/s/fXCxDLGyhCl7o/8zhFRBDGAI6pQQQRGtz28C7c+vAtVIhg3KcfOrpvys67K63NtZ+NVbfN0Y2i8FmvG2nJGAQDIm2fnOojy0SDBVat/t4FqiRs1RGZ9I0UHB6cTEdliCSVRhbIKgLwERtmQzSx403fDNCsvdDsLz+tzbQNTuxtDE8Zr0Z1uRfvojTiA6fBdUmXVCMFFgwTHslJDWaRdeeZwcqbpe+i3B1WSamQsUfVTxmsqCmV4lSLIa83ujxQG/ntAZYQBHFHcBPR/QkEFRnpVIqbrpozr77ysq/L6XNvA1OONodk1errqQ3j26l8BHUPaLKhCMwIXr9Kyd3q6bJ7d5+yYPfUQqK4ZXYZhVZuzbVjVYs3oMgDhBll+1kY68hDExloUbkqDvtY+frlBZKpS/j2gisESSqI4CXBtiNc5b1aljHpppbCvc7Hl+xVaGuflubaz8X7prS14qLPw7GaLOXzOjmWlHgLV7x+7AG8mRrCyuguNchgDahrWjLXh8bcvQAccSlJ9XodQZ85VQhleVNaKBX2tL15l3v0x+8sNJx7WuVKFqIR/D6iiMIAjipOA/0/Ib2BkVPJZYXAIuqq83xiGNYQdgHWDBIfP2WmA+3ByJupSb+S97HByJuoM2xrrk+geakX3SGvO9qbMZxlmkBXqzLlKKMOLyk1p0Nfaz+B0v0Etg7/yVAn/HlBFYQBHFCcl/D8hfWDUP5SCYHINHOB+TVsxWAZdfm4Mi8nhc3bKDK4ZXYaV6v6cZivZssgOw0s6BYNhBllO7+1LJQxhjspNaRjXutDuj36C2qhkNCl4lfDvAVUUxwBORL4L4EoAB5VSc00e/zCAxwDsy2zaqJRanXnscgD3AagCsEEp1RnQcRNVphL/n5A+MIpt90CfbcGLct4uPme7zKBTWaSeUzAYZpAVaomqWRleogYYOa6tF4tq8O6F1fdEEsU9R78lj17ZZcn8BLVRyWhS8Ir9HSUKmZsM3PcAfAvAD2z2+Y1S6kr9BhGpAvBtAJcA6AOwXUS6lVIvFXisRBTy/wl5CU5CLS2MKFft+4Pg83N2Kos0svssQw2yHN7bl3lt2P7aEcx6fi1mqEG8JafgHeoEqrKz98ohu2L2PQEAlQm2i3WOxcxsO2XJ/PySKyoZTQpeXKoviFwSZdL+O28nkdkAnrDJwP2rSQD3dwA6lFKXZX6+HQCUUnc7vd+CBQvUjh07XBw+UQUKaY2GMTgBtExLTsfHCl8f0tK51bScsKk+iW3ti4J9Mx/X2tVnWeaM16Cn9hY0J8yGsM/SuonGlf57IonJ4E0v7ueot26uRYCWOUdjgAdov/xwM+7D6bWJiIpMRHYqpRYYtwe1Bu7vROQFAAPQgrk/AGgCoP+XsA/A+wN6P6LK5bME0Ipjt0GuDwm3a6KRj8857KxZHBi/z41iErwB4WRXivmLDv33pKPefJ9yyiA5Zcn8ZFpYZkdEMRFEAPc8gPcopY6JyBUANgE4A4CY7GuZ7hOR5QCWA8Bpp50WwGERkRe+ZouZ3BzFdo2cjVC7Jhr4vX6VWOKqZ/w+D6gGNJsFcUGvHy3lLzoqoVGDm3Ms9JcfLLMjopjwPchbKfWWUupY5u9PAqgRkQZoGbdZul2boWXorF7nQaXUAqXUgunTp/s9LCLyyHYANuBpfUiYw59Lyevw80KV6/UrJuP3ec1YW97Acl/ZFasB2h6GqAfOaTh8OQj7HOe1aeWSHUPanwzeiCiCfAdwIjJTRCTz9wsyr3kYwHYAZ4jIHBGpBXAdgG6/70dE4XAMTqx+i2+y3a4cM+o29fajpXMr5rRvRkvn1pygaen8Jtx9zTloqk9CoK19C2NdWSHXz+64i8oqsCky4/e5O92KVWo5hpPvBiDauiY366LMZLNsR/cDUJNZtt1dpW2EMa9NO6eps+D7HENW8Pc1RudIRBQWN2MEfgzgwwAaRKQPwF0AagBAKfUAgGsB/LOIjAFIAbhOaZ1RxkTkJgBboI0R+G5mbRwRRZDjuikP60OKulYsQG66TJqNUrjt4V2Blol6vX5F647pJELrJM2+z62XfR5187/q/8XtsmylLmMMaY1skHx/X2NwjmWlwptXEUWRYwCnlPqEw+PfgjZmwOyxJwE8WdihEVGx2a6b8rA+pJhrxYLk2MhFJ8ygyev183Lc2WMPZX1ixOZohbYO0C7Lds2D8W2EUaQbda/f17IVh8AoQr+UIaJJQXWhJKJK4PI332EOf/bLGLxcdNZ0/OLlQxjIrDczY5b5CvMm1Ov185KxCzVbVylztOyybHFthFHEG/W4ZugDFZfAKGK/lCEije81cERERsVaK+aVWXOQHz77XxM/WzHLfIV5E+r1+jk2oNEJdX2ih3WSlrysoSvVejunRhpxbIRRxOYrXr6vZauUzW68qJRfyhDFDDNwRBSKKLaxNwtenFhlvsIuE/Vy/bxk7ELNfvido+UlK1HKDEZcs2x2CrlRL7AEMMoZ+qKJS2BU6jWdRGSKGTgiqhheghSnzFexRgq44SVj5yr7UWhmy2+HQC9ZiVJnMOKYZbPjNXtq14nTgecMfUQ6mwYqiGx1MVTCaAqiGGIGjogqhlXWzKipPolt7Yts93Hs2llkbjN2jtkPv5ktPx0CvWQl4pLBiAuv2VOfa6NcZ5jjslbMK7/Z6mIpx2wzURlgAEdEFcMseDHykkULukzUrjtkUJ0jHQPPUjYt8FKuZbWvJLRMDW80nRlLIN93PfDKU+5u1IMOoK3KMcu1iUacAiOObSCKHAZwRFQxzIIXfRfKUmbR7LpDAgi0c6Rt4FnKzJaXrITZvgCgMsF5uWRqjIJqPW+W2XrhIfclr0GujbLLspVzppWBEREVSLSZ29GyYMECtWPHjlIfBhFR0bR0bjUt72zKrE2zesyp1NOzdXMtbsxnaWu9HPjOFHoJUPT7SmIyeHNz3HGYwWVkDHQALcD1ss4wy+fnXLRjAfwdZzEZv1NnXOo+o0lEZEJEdiqlFhi3MwNHRBQBhXSHDGVulo+1OYHMmPOSldDv21Fvvo9ZpmZ3F8YeuxnV4ycy++zXfs6+ZlQFWU7oN7MVZAlgkQejhzLI3iyLuOPfJx8v14wwEZUEAzgiipxQbrAizmksQZgjC3L4uDEPc7i5Iw8lfcM/X4W6bPCWUT1+Qtse5ZvrIMsJgyiBDKoEsIiD0UMbZG8WXBuVw9o9IooEBnBEFCmh3WBFnFN3yKLOzSrwxtwqI9g/lMKc9s3hBuMuMofZXwz8JvWGNifCYErqQPDHBQRXrhnkurModUF0Oha/gaLu+l+IBlwy/nF0o3Xi4UB+yeA2iPYSbOu/N8l3attSR1iOSUScA0dE0WKXxSlndrOxPM/NKhG7jKDCZDC+qbd/8oGgZnw5zKDL/mKgfyiFAdVg+hID6WmFvbcdH/PS8gQ5k8vvzL4ghXkshus/E4fQWbMBSxI9Obv5Lkd2G0S73c/4vUm9qf3n9ztERGWBTUyIKFLmtG+G2b9KAmBf5+JiHw55YMyeWplovhJkIwwH+iYxSxI96KzZgDoZmXh8WNViTc3n0XHnlz2/tm3Jr99mIUYhNl8py9Jli+vfl25A68j6iZ99NwQy+y4befluW31v9KLYyIWIAsUmJkQUC05rwSi6jGMazALxJYkerBzuQvquQaQlgWqkc3cIaZ2QPsPSnW4FRoGV1V1olMMYUNNwL65D6+LlE/u4DWYcS36DboPvtZzQEPBtP/1m3PrSGXnnVbalyxbXuVEOT/w9kHJks7V6frpQuvl+lMMoBSIqCAM4IooUp7VgVHp2wY1+xpxxNIIx85UwBm9ZIdyYGn8x0J1uRfeItg6qqT6JL8zoxYWPfQjpTYdwQBrwq7Fl6B9rAWAfzDg2bgly3ZpXJp0R5+68E+eP3oh+tOacV0kb0ITJ4voflAYIEGymMci5blbfG+M+RFSRuAaOiCIlLuu9KpV+LVl2XdttD+/C7PbNaOncmrO+bcVlZyJZUzXx88rqrpyyRUsh3JgajwXQfjFw77Jzce/Zr+Cq1zsxE4eQEKARg/hq1f/JWSdltQ7TcfzDxaswVjUl57Gxqinu1635WSNo0hkxKSNYWT35GtnzKmSMRVRs6u1HS+dWzDH5DlqtG5x5zdewr3MxtrUv8vdvi5fPx8u+ZsdtOIeSNJwhokhgBo6IIkefxaFoMcvUZEsljZkqY0lloww6v0FIN6Z5x6LLvBx4bC2ShsCyLhPoZLN0gHkw41Tyu2m8BT2jN+JW/GSyXDN9HVrHW7DU6aDNZot5mSXmonwQwMT1iGPpsmPpZ8BjCHJ4+Xy8fpbG43bqQhnHwfREVDA2MSEiItesmszoWTWEONDx15iJQ3nbx5BANVTJbjzTd01FwmSsQFoJ3vv2jyZ+NjuvTb396Hn0/kyANogB1aCtp/vo57F0flNeGanda+Xx2wDFQwMPq9LlqGe/fV1fv7x8PkE3s9Eza6CSqAFOegfHDhDFnFUTE5ZQEhGRa24yMlZld/vPW4GUqs3ZllK16D2vE+gY0m5kS3CTeVCmm24fUJNjBazWYS6t2obOmg1oTgwiIUBzYhCdNRuwtGqb9hp+ShP9NkAxKcNLqVqsGZu8xtnzimvp8sBQCksSPeipvQWvnnQ9empvwZJET3FKP718PkE3s9EzGyKeHuXYAaIyxgCOiIhcM1tLZmQV5C1c8jnsOf8rOIDpSCvBAUzHnvO/goVLPhfGobpmFlgOq1p8O3G9czDzzGpUj5/I2VQ9fkK7qYb1tXBVmmi1FtDtGkGT+Wp7zv8Kdp56iel5LZ3fhG3ti4JZG1YknznlOdMA+jOnPBf+m3v5fPx+lnbcBIHZ7q5uBDWbkYhCwxJKIiLyJNuFsn8oBQFySipLWXbnZ47Z9u7vYNbzazFDDeKgNGD/eStsA8vse/0m9VHT8ktAgI4h09l4rq9REefkxdXwPWehLvVG/vbku1H3pZfDfXMvn0+Yn6WbmXEAst9JW/zOEUVKwXPgROS7AK4EcFApNdfk8U8C+FLmx2MA/lkp9ULmsdcA/AXAOIAxswMgIqJ40TcoicrwZ79zzBYu+RyQCdhmZv5z814DtQ1oNmvOksms2DVPcRRmA44yUZc64Gk7gNyGH07NQex4+XzC/CwvXuU8RBxwl+0zK8d0ms3IBipEReeYgRORD0ILzH5gEcB9AMAflVJHROQjADqUUu/PPPYagAVKKRetxyYxA0dEFKyoBFpO9Mc5NVkDEWBoeNTxmIvZzEL/XsbZdgDKN2MRxRt1r81BzDJMenH97IxB6cgxYLyA72RHPWDapsgie8eMHVGoCm5iopT6NYA3bR7/rVLqSObHZwFwsiQRUYSYzW67feOLufOyIsB4nEOpURwZHnV1zMWcY6Z/ze50K9pHb0RfugFppa0zK8ub1+yN+tH9iFRjDIs5b5ajKMwyTHpe1opFybw2LWDtGAK+tA+4+ts5ax9dfye9rtWzy9gRUWiCbmLyjwB+rvtZAXhKRHaKyHK7J4rIchHZISI7Dh3KbzNNRESFMZvdZjWYupTMjlMvNTqOL3a9YDqw2VezEI+Mr9mdbkXryHr8fXJjyTpphi6qN+omjVpsgxU3DT+C6AxZavqAzst30mtAHGZ3TYo2NrspqcAGeYvIRdACuFbd5hal1ICIzADwtIi8nMno5VFKPQjgQUAroQzquIiIKl0xs1N+uDme8UzZv3GNm9UcM7PW/34F/V6RLW/Vl+VZTf+Lwo36vDb3AcrUZueGH0F0howrr2v1rK5nFK5hFEt+y4XXwfQUuEAycCIyD8AGAFcrpQ5ntyulBjJ/HgTwKIALgng/IiJyr5jZKT+8Ho8+i1jMOWZBvldky1uNJZNWonCj7oVZhkknpWqx/fSbi3hAEeQle+c1Y1csfkt+mV2yF9WMfAXxnYETkdMAbATwKaXUf+q2nwwgoZT6S+bvlwLgJ0tEVGTFzE75YXacTvRZO313zLAF9V525a0lzcI5rRUDMFY1BdWZG/XIZhGNdBmm9NE+HEmfDBGgHscxoKZhzVgbdr50BrYtKe1hFpWfTFVUO6UW0k0zi9klZyydLTk3YwR+DODDABpEpA/AXQBqAEAp9QCAVQCmAbhfRIDJcQF/BeDRzLZqAA8ppf4jhHMgIiIbvlrZF5HxOPVdKBMiE+WTelHLInoV2fJWixsxpQAFwYCahnvT16F1vAUwGeHQ8+j9uPSpR7R2/lObgTMuBV55Kho3+ZmSy9PbN5v3Wyz1tS+mIIIVLyWsDgL7RYCfAMNP8Fcpolw6WyEcAzil1CccHr8RwI0m218F8L7CD42IiIJSzOyUH1bHaTUQO2pZRMDbTWhjfdJ0/EFoganbbIvFDVq/akDryPqJn3+XKWHVfy5LEj1YLRtQl8q0sT+6H9jx75MvEpGMRtGvvZNSrNmKULDid5ZjDj8BBrNLzsxmD0ahdLaCBN2FkoiIKHDFXOPmh9c1bSsuOxPJmqqcbUEGppt6+9HSuRVz2jej4yt3Yeyxm92tCzJZ2zSsarFmLPemfmAolZctXFndlTsXz0wE1ssEfe3119rYJdVRqcY0RChYCbRbrp+1eV5HKVQir91f/eKaxDyOg7xLgYO8iYgoStxm1QoZKG587YvOmo5fvHzIdxmZMaPRU3sLmhOD+TvaDb3OZIQOoAFfG/k4utOtObs0ZbJV+nN+9aTrkRA3Rzg5HLpUa+iCel+rDLHrXzJ4HUgelFK9b5buO9aX1tYgGr9jAmBf52Jfr+0po1nq4eTsnpmr1J9HiVkN8g5sjAAREVE58lLaVciaNn3ZaJBlZMaMRqOYBG+AdbZFt7bp2d5+PL3xRSBtXsKqP+YB1YBmq/fSy2Q0Ai2dg7egLDLNaEqVCStlKZzhxrw5MYjOmg3AKHKCuIJLWgtdm1fKxixsoJIvQmW+UcISSiIiIhteSrv8jmwIsozMGDQOqAbT/frS0xxL/uxKWI2Pbai9AWNVU+wPThckBHnOpRrL4LsZTanK9opdCqdncmNeJyNYWT1ZHleyda6FDkL3q9jt+eNQmhihMt8oYQaOiIjIhpebc78jG7wGAnbZJmOTjjVjbeis2ZCzPi27rs1N1ssuW5X72GJg99/mZjBsulAG2Ykz9LEMFuVtvhui+MyE+SoFDbCLpCcWN+CNicMQwPt5xLX0UH/cVjMXs9cqyHMMM9sX5HGy46UpBnBERBRLxVo35eXm3M3IBi9Bl917OZUeGoPJ7nQralUCq+sewZTUAQwY1hwFGuh4CAqcztnL5xzqWAabG94Vl7X465Lqo2wv6BLUUOlv7CUBqPyZj4mpzdjX4XHNW1xLD83Wd5mZ2hz8OYZVmhj0cbLjpSk2MSEiotjx3TSiRO/l9Fpe3stNwxSr4GeO1Qw0FNgwwge7cwbg6doX0kTGNYeGH6VqxBL0OYd2Hm6ClUKbU5S6GUuhrI5bL3tNnlkd7Dl21MMy4zd1VuFZszA+i7hmVwPAJiZERFQ2Qi+V0wlyELrTcXt5LzfZJquyxyjNQLM755bOrZ4+Z78lrLYc1uI4NUQJKzAKMutols1b8dMX8OXH/4Ch4VF/x22W8QEAqQJU2t+NeVzXSdken+Rek43LC3gNG1aliYC/rFkYn0WpynwjjAEcERHFTqilciaC6lboJ+gy8hOEhRroFMDqnL1+zkEG23l8rMUJs8yxkO+BVTBp9guG0bTCkeFR/8dtdQOv0hPjJAoWo3VS+mv/uykNmIlD+TuZZauCPkez0kS9QsspY/RZxBm7UBIRUez47fZYKkEet59B1HEZjF7I9Vo6vwnb2hdhX+dibGtfFNw5+RgO7abTpqdB4LrugU/L53Ft7W9zHrb7Hth16nTzC5CCh2uH2WnTz+Bu+BzCbmTT2dF47b828nGkVK274/Z5jnlyOpBaKCRrFvRxkilm4IiIKHailkFyy+txOw35/tj5TTk/X3TWdKzdshe3PbyraDPQ3Ci0fDBSn7OPRiNOmURPGTrDWrK61BvorNmAU2qr8f1jFzheX7tg0iqb5/Z8bJlkfMaqpuArxz+G77dv9pctjUoTGIcGHsZr351uBUaBO2p/ipkYtD/uMObTZUsTLdetWQfXlv+bLuUcvQrCJiZERBRLpWoa4Zfb4zZr7mFUaAOUUp/HtbW/xeqTH0Fd6oDjDZ7fzzkK3xOnRiOeGpH4bBJh18Bm3bJzHb9zlsflhq4ZxXByJlYd/xh+NvKBiYfD/L5aCbQJjMNnU1DzoGI08DBrMGPTUKbY/9ZUMjYxISKislLMDFKQ3B63WabESN/Qo5iNXbxkLYzHtSTRg9WyAXWpzDw6h4YJfj7nqLTYN8sk1iQEwyNjljf1gEWmy2eTCLs1c8Y1hFOTNTg+MobR8ckj9JUB1TWjuKRzK/pHco8jrO+rnUDX0zp8Np7XKxZrPILHrFkx/60hc1wDR0REFEFubyCz+xWzsYubNV1W77+yuitnmDiAyYYJJTzOMBnXHNYnawABjgyPWgZvgMWNvc+1ZE5rJ/VrCHfddSnWXvu+UNZKFrsRkZVA19NafAYH0IA57Ztx/O0x1FRJzmO2AbHdrLagzWvTMrgdQ9qfNgFiVD67SsYMHBERUQS5XY+UvdEs5mgALzdwxuNqlEHzFw2h5XuUbjT1mcSWzq0YSo3a7m95Y1/IYGNdGd7Sqc04570tOPn1ZzBDHcJBmY79563AwvmXOx53kEo9yiJbWts/lIIgdyKa5yzjxPXdDxheLaVq8bXRj0MBGEqNoiYheGddjbuxDBEdj1Dqz46YgSMiIooks0yJkf5G009XSq+8ZC2MxzWgGsxfNIQ241HtVmoXQDpmunK6B4r2p93w62wZ3tH9ABRwdD9Of/0nmIlDSAgwE4ew8MW7crolFkMxv69G+m6QgBZuZfNinrOMOdc399UOYDq+NHqj1qwkYzStUFdb7a5LapidO30o5WdHGmbgiIiIIshsppmxC6X+t/ehzkAz8NId0nhcG2pvwJ3qAVSPn5jcKaQ245HqYqljlcFw3TjDy2BjqwHaeoXO/DLw0jDG7Pt679mvYOEv/xV4LNzuhWaltQoFNi4xvb4KmDoLf/ff95iWyLrOABeSbS2CYv5bQ+bYhZKIiIg889XdsRid9YI4zpAUtYtfRz1gu9IuS3wN1PZ9Th47IfpRUDdIK5bXV9AyZaP/DpdF/N9K0ZTjOYWEXSiJiIgoML7WRnnJIPkUxW6lRc1gTG02b21vtp8Pa7fsxSXjv8LK2i40yiAGVAPWjLVh7ZZad+dl17Aj4O9KoGu4rK7v1Gas+HAAGeAi/m+lKIrVWbPMMYAjIiKiPFHMXBVbmNegaIGlWRmeUQBleQveehp312yY6DDaLIPorNmA298CABfZpiI27PBcWmuXMbIpc1w6j6WGeYoYqJczxwBORL4L4EoAB5VSc00eFwD3AbgCwDCAzyqlns88dnnmsSoAG5RSnQEeOxEREYUgKvPTSqlsrsG8Nmx/7QhmPb8WM9QgYoL6wQAAIABJREFUDkoDjr/nYpw+tC3QErbba3+KOuSOh6iTEdxe+1MAdzu/gFUmSxJamaLxOH2U4XnKgDpljBxmqEUxA1xSEe2sGTeOa+BE5IMAjgH4gUUAdwWAm6EFcO8HcJ9S6v0iUgXgPwFcAqAPwHYAn1BKveR0UFwDR0REVDotnVv9r92JIX3GLSGCcZN7pCoRpJWKTTalWOvtVEc9xGQtmIJA3KytM1sDlyfToj/5LmDkGDCuCxgN6+UCy56um2tRIjlLm5dWrsJapxby9Sy3yoGC18AppX4tIrNtdrkaWnCnADwrIvUi8m4AswH8SSn1auYAfpLZ1zGAIyIiotKJ0vy0YjEGOmbBm357XDJydsPMCzluqxtkscigidu1dcZMliQANW7YKfOZpN7Mf76uDC/Q7GmRM0aRCECCXqemDwaT7wSqavOD7wA6a5ZN1tyFIObANQHQ/y+2L7PNajsRERFFmN/5aZt6+9HSuRVz2jejpXMrNvX2B3l4oTALdJxkAyEzUbkGQQbj+vlpCpM3yJt6+7Ub8BrD98Prjfm8Ni0L0zEEqLTn48sGVXZBq2dFnMVme33d2N2lZbg66rU/Pcz2039fD2y8w3qdmlfGOYSpNwGVyaK6mWPoQaCfe8QFEcCJyTZls938RUSWi8gOEdlx6NChAA6LiIiICuFnUK/vm9ASKTS7aPa8KF2DIIeZ294gex0w7qSQACnznEAzyGaBaaIGGDleUKBkx1cAYjKwHY/f4urYjN/XGcriPryQrKNZ05L0KFB7shao37YnsOYllVQ5EEQA1wdglu7nZgADNttNKaUeVEotUEotmD59egCHRURERIVYOr8Jd19zDprqkxBoa9/crpmK62/BrQKaKhFI5k8zCZG8LFuUroGfYNzI8QZZn0Hze2NuFjjZGKuaMpHtCzJozQtMk+8CRDJlnN4CJSe+AhC77o4OjN/XAdVgvqNdUG2V/StiCWpjfRJLEj3oqb0Fr550PXpqb8GSRE9hn3vEBTFGoBvATZk1bu8HcFQp9YaIHAJwhojMAdAP4DoA1wfwfkRERBSyQrvnhf1b8LDWCFm1ls8GrmbNQADzNXFRygQ4dVz0cj0b65M4/62nsbI6d9bbzlMvCf7Ac9bE7cdEA5OMEVWFY0iiHscxoKbh3vR1aB1vwVIUMCbAzbFkj2fd3Pw1eAG1wfc1n85HoGT8Xq4Za0OnbiQEgNyso1lHUKs1czZz8oJ279mvYO7ODUjqRlncU7MBe86eDctRFjEdKu5mjMCPAXwYQIOI9AG4C0ANACilHgDwJLQOlH+CNkbgf2YeGxORmwBsgTZG4LtKqT+EcA5EREQUEYEOSTYIs0mBU6BjfNysS2U2yxbmNSiEVTDu9XoWdIPshz5w0t1oH0ADvjb6cXSnW3N2/12mMUuog9JDzCj5Cjx9BErG72t3uhUYBe6o/SlmYlBrPDJybDJwNTY1scv+2czJc8vtLxkW/vmbgOSOskjKiLYdn8t/4RgPFXccI1AKHCNAREQUT2G2rY/SeIM57ZtNF/YLgHXLzi1K636/PF/PiLTUt7v2+zoXh/vmXq+BxwxPwRlmszEMhtEKdu9p+311OueOepi3uRCtnNZHlsvTvydOx2EUke+znYLHCBARERG5FWb2I0qliXZZtlAzQAHyfD0tskzpo304vX1z0c6zpBlOLxmlAjI8BQ/+Nhsofsal2s8bl0/+/MpTeYGU4/fVKevolP3TZ1I9chyDoQ8OTUdPwDoLGeOh4gzgiIiIKFAF34Q6iFJpolO5W1jXIEier6fFjfpAelpOt00g3Llbga9x82JeG7a/dgSznl+LGWoQB6UB+89ZgYVmAYpdaWEYJXrGklNj8Ljj3yf3NQSTtt9XpwAtgDJJK7a/ZDCeo1nwZnccRVyfF7QgulASERERhS7Ijop++enUGRWer6dJZ8hhVYs1Y5PBSDG6bZby2m/q7cent78HF564D+99+0e48MR9+PT295iPiLDM8OwPfARBHrPg0cjtbDenGX9Bj5DQse0oanWOUuXuOIKYXVgiXANHREREkWK3DiisLpRRU6zz9Pw+upK1vvQ0rBlry2smUpS1aCXiad2g1RorPZfr1DyzXA9mZLE+zKhE3Rpt18A99rfwtObNTMS7UFqtgWMAR0RERJERZhOUuDC7Btkm+k0RClqj1FSmWDw1UDFrLGImjKYZboLHsN47YJa/ZIhBExK/rAI4llASERFRZERpCHapmF2DbNCQXWdmWrJXZFEqaS0WT0PCjaWFVsJomuFmEHpMygWXzm/CtvZF2Ne5GNvaF03+8iLGJZB+MYAjIiKiyIhSp8lScTrXqAS05bAO0CvPQeu8tkyr/aFMIGcioKYZm3r70dK5FXPaN6PlyQZsP+fLuevSFvxjKOvUisnxHGN4ToVgF0oiIiKKjCh1miwVq2ugF5WANg7dNoNk1nL/orOmY+2Wvbjt4V326whD7NZoNpT909vfg7uv2RK5z6fQ9Z2BnGPE17y5xQwcERERRUYlluUZmV0Do0oKaKNGX9K34rIz8cjOfvQPpXJGKZiWuIbYrTEupcfZIMzV9TLwfY7ZNYlH9wNQk6MUwuoEGiJm4IiIiCgy4jIEO0z6a9A/lJpoYJJVaQFtsXnJEDkOmjbyMdTaTlxKjz1fLx3f52gxl+/Axjvwdw+dHKt/axjAERERUaRUWlmeGf018FpyFplRCzEsVzMr01vx0xfw5cf/gKHh0bzr6TeoCOqzilLpsd05+blevs/RolnMDDVY1EH0QWAAR0RERBRhxoA228jBak6eMQApyU2psYV+tlwNiHQQZ5YhGk0rHBkeBZB/Pf0EFW4+K7cB3orLzjQdv1HsTK3TOfm5Xr7PcWqz6diBATVt4u9us4GlxjVwRERERDHhtIYoMmuhLMrV8Mzq4h6HR24yQfrr6WfNptNn5WW9mFlH0I+d34S1W/ZqHRs7t+LOTS9OdnDs3BrKKAqnc/JzvXx3PTUZOzCsarFmLPcXClErOzXDDBwRERFRTDitIYrMWiiLcrX00T6c3r45suuN3HQABSavp581m06fldf1YsayW2Mm7IfP/tfEvmFlZp3Oye8aV1/l1dnMb6as9wAa8LXRj6M73ZqzWxwaBDGAIyIiIooJpxvkyKyFsipXS0+L9HojszI9M/rrWWhQ4fRZ+QnGzYI/ozDKBd18/0q6xlXXRObZ3n48vfFFIF3astNCsISSiIiIKCasArHs9siMYXBRrhbFNvfGMr36ZA1qqiRnn6Cup9Nn5fRZY3cXsG4u0FGv/alrh+8249o/lAq0pDIy3z8X4jyInhk4IiIiophwauQQmTEM89qw/bUjmPX8WsxQgxhQ07BmrC2vXC2K643Mmsa4vZ5e9nX6rGw/a4cmMW5LQQEEmhGNzPfPpbh2vBWllPNeRbZgwQK1Y8eOUh8GERERUeREZkyADeMaLCtN9Ulsa19UpKMKl9k5J2uqfGV1LD/rdXNNS1QxdRZw2x7X198o8p+H19EUMRxloSciO5VSC4zbmYEjIiIiipE4ZA3crMEKsrTOKagtRtDrZ0i1FcvP2qJJTHa7WSbsorOm4xcvH8JApqulmWxGNJK/JPA6miKmoyzcYABHRERERIGyK40UINCB5E6zx8we73n0flz61COoSx0ILDNT1A6gFk1iMLV54q92gX5L51bLZiORmSVoZDeawuyz87p/jLCJCREREREFyqoBR1N9Evs6F2Nb+yLH4M04A+22h3dhtknDDafZY8bHlyR6sFoeRF3qDQBqMjOjawJSCMemI0EyaRKDmqS23QW7ZiORmSVo5JB19L09RlwFcCJyuYjsFZE/iUi7yeMrRGRX5r89IjIuIu/KPPaaiLyYeYwL24iIiIjKnN9uhGZBRLbszzjQ2inzZXx8ZXUX6mQkd+cAhowXtQPjvDbgqvXamjeI9udV611nluw6MEZmlqCRLrsYyvYYcSyhFJEqAN8GcAmAPgDbRaRbKfVSdh+l1FoAazP7XwXgNqXUm7qXuUgpNRjokRMRERFRJPntRugULOjXljnNHjM+3igWt6Q+MzNF78Com2lWCKsSy8jMEjS6eFXumjbAPuvodf8YcbMG7gIAf1JKvQoAIvITAFcDeMli/08A+HEwh0dEREREceSn2YqbNvjZIM9ptILx8QHVgGazIC6AzEwcGsw4cbqeXjmuZXTbKTK7zW1XSa/7x4jjGAERuRbA5UqpGzM/fwrA+5VSN5nsWwctS/fX2QyciOwDcARa5vs7SqkHLd5nOYDlAHDaaaed//rrrxd8UkREREQUX27a4Otb3nvpQvmZU57DneoBVI+fmHyxmqSnEsRyZ7ye+g6WXrp8Oo5W2N2FscduzvksxqqmoPrqb/KzgPUYATcB3McBXGYI4C5QSt1ssu8yADcopa7SbWtUSg2IyAwATwO4WSn1a7v35Bw4IiIiosqWDQr6h1IQIKf1vd/5ajlZn+Q7tW2pI2WVpQmKUxBm93j28zPKBt/D95yVaSaTazj5btR96eVwTihGrAI4N01M+gDM0v3cDGDAYt/rYCifVEoNZP48COBRaCWZRERERESWls5vwrb2RXitczHWLTvXtOFGwea1AbftAa55EBhLAak3EWRHynLitcun/nGnhihTUgdMH0+m3gA66rWB5fws8rhZA7cdwBkiMgdAP7Qg7XrjTiIyFcCHANyg23YygIRS6i+Zv18KwF+LHyIiIiKqKKGtLSvjWWFB8drlU/+4U0OUgfQ0NCfy1yMKgJyAGijo84jkQPIAOGbglFJjAG4CsAXAHwF0KaX+ICL/JCL/pNv1owCeUkod1237KwA9IvICgOcAbFZK/Udwh09EREREVKAynhUWFKf5dnaPO41W2FB7A4ZVrf0BFDjiwWyWoH78RJy5mgOnlHpSKfU/lFKnK6W+mtn2gFLqAd0+31NKXWd43qtKqfdl/vvb7HOJiIiIiEqujGeFBcUpCLN73G7eHACcu3g5Vqnl6Es3IK0Elq05CgioIzuQPABuSiiJiIiIiMpPjGaFlaoc0Gm+nZvHrY5T2/55LNtyMQaGUvjdlC9gJg7l71hAQB3ZgeQBYABHRERERJUpJrPCjJ0es+WAAIoWxNm9j581ijnP3X08sIA6sgPJA8AAjoiIiIgq17y2yAVsRnblgOXQlGNCgAF10APJo4QBHBERERFRhJVzOWCegAJqp9LOOGMAR0REREQUYeVcDhim0MZPlJirLpRERERERFQaTp0gqbIwA0dEREREFGHlXA5YTOUy2JsBHBERERFRxBnLATf19qOlc2vsg5FiKXUnzyCxhJKIiIiIKEaywUj/UAoKk8HIpt7+Uh9aZJXTYG9m4IiIiIiIYqRixgo48FISWU6dPJmBIyIiIiKKkXIKRgrlNQtp1bEzjp08mYEjIoqZ0dFR9PX14cSJE6U+FKKCTJkyBc3NzaipqSn1oRDFEscKeM9CltNgbwZwREQx09fXh3e84x2YPXs2RKTUh0PkiVIKhw8fRl9fH+bMmVPqwyGKpXIKRgrlNQtZTp08GcAREcXMiRMnGLxRbIkIpk2bhkOHDpX6UIhiq5yCkUIVkoUsl8HeDOCIiGKIwRvFGb+/RP6VSzBSqErOQjKAIyIiIiKiWKnkLCQDOCIioph77bXXcOWVV2LPnj2Bv/Yvf/lLfP3rX8cTTzyB7u5uvPTSS2hvbw/8fYiIvKrULCTHCBARlblNvf1o6dyKOe2b0dK5NfRBr1dccQWGhoYwNDSE+++/f2L7L3/5S1x55ZWhvncs7O4C1s0FOuq1P3d3lfqIXFuyZAmDNyKiEmMAR0RUxrzOyQnCk08+ifr6+rwArpjGxsZK8r6OdncBj98CHN0PQGl/Pn5LIEHc2NgYPvOZz2DevHm49tprMTw8jNWrV2PhwoWYO3culi9fDqUUAGD9+vU4++yzMW/ePFx33XUAgOPHj+Mf/uEfsHDhQsyfPx+PPfZY3nt873vfw0033QQA+OxnP4tbbrkFH/jAB/De974XP/vZzyb2W7t2LRYuXIh58+bhrrvu8n1uREQ0iQEcEVEZs5uTU6g1a9Zg/fr1AIDbbrsNixYtAgA888wzuOGGGzB79mwMDg6ivb0df/7zn3HuuedixYoVAIBjx47h2muvxVlnnYVPfvKTEwGFmdmzZ+Ouu+7Ceeedh3POOQcvv/wyAODNN9/E0qVLMW/ePFx44YXYvXs3AKCjowPLly/HpZdeik9/+tP43ve+h6VLl+Kqq67CnDlz8K1vfQvf+MY3MH/+fFx44YV48803C74GBXtmNTBq6Jo2mtK2+7R3714sX74cu3fvxqmnnor7778fN910E7Zv3449e/YglUrhiSeeAAB0dnait7cXu3fvxgMPPAAA+OpXv4pFixZh+/bt+MUvfoEVK1bg+PHjtu/5xhtvoKenB0888cREZu6pp57CK6+8gueeew67du3Czp078etf/9r3+RERkcZVACcil4vIXhH5k4jk1U6IyIdF5KiI7Mr8t8rtc4mIKDxe5+S48cEPfhC/+c1vAAA7duzAsWPHMDo6ip6eHvz93//9xH6dnZ04/fTTsWvXLqxduxYA0Nvbi3vvvRcvvfQSXn31VWzbts32vRoaGvD888/jn//5n/H1r3/9/7F35/F11nXe/1+f7GuTNEnTJmmatE1butGWUqhdZC8oSFVUNhdccGNk9Dfcgo7LqKMoszkz3jfDIIrKIiNYwYXiAEoLIl1JF6DpmiYpbZNm33PO9/fHdSU5SZNuJ8nJ8n4+Hnn0XNe5zrk+5+Jwct75bgB84xvfYPHixZSUlPDd736Xj3zkI93Hb9myhd/85jc8+uijAOzcuZNHH32U1157ja9+9askJSWxbds2li9fzs9+9rNzvgbnrK787PafhalTp7JixQoAbr31VjZu3MiLL77IRRddxIIFC3jhhRfYtWsXAAsXLuSWW27hF7/4BTEx3nD45557jnvvvZdFixZxySWX0NraSllZ2SnPuXbtWqKiopg7dy5Hjx7tfp7nnnuOxYsXs2TJEt58801KS0vDfn0iIuI5bYAzs2jgR8A1wFzgJjOb28+hG5xzi/yfb53lY0VEZAgMtB7OqdbJOZ0LLriALVu20NDQQHx8PMuXL2fz5s1s2LChV4Drz7Jly8jPzycqKopFixZx8ODBUx7/vve9r/ucXcdu3LiRD3/4wwBcdtllVFdXU1dXB3hjtBITe17bpZdeSmpqKtnZ2aSlpXHdddcBsGDBgtOee0ik5Z/d/rPQd2p+M+Nzn/scv/rVr9ixYwef+tSnaG1tBeB3v/sdn//859myZQsXXHABnZ2dOOd48skn2b59O9u3b6esrIzzzjvvlOeMj4/vvt3Vmuqc45577ul+nr179/KJT3wi7NcnIuPDcI/bHo3OpAVuGbDXObffOdcOPA5cf4bPH85jRUQkTHetmU1ibHSvfeGukxMbG0thYSE/+clPeMc73sGqVat48cUX2bdv31l94Y+Ojj7tWLWu40OP7a/bZVd4SU5OHvB8UVFR3dtRUVGRGSd3+dchtk94jk309oeprKyMv/zlLwA89thjrFy5EvBaMRsbG7vHqAWDQQ4fPsyll17KD37wA2pra2lsbGTNmjX8x3/8R/f13bZt2znVsWbNGh566CEaGxsBqKio4NixY+G+PBEZByIxbns0OpMAlwccDtku9/f1tdzMXjezP5jZvLN8rIiIDIG1i/P43vsWkJeeiAF56Yl8730Lwp52efXq1fzTP/0Tq1evZtWqVdx///0sWrSoVytQamoqDQ0NYb6C/s/9yCOPAN7MlllZWUyYMGHQzzMkFn4Qrvt3SJsKmPfvdf/u7Q/Teeedx8MPP8zChQs5ceIEn/3sZ/nUpz7FggULWLt2LRdeeCEAgUCAW2+9lQULFrB48WK++MUvkp6ezte+9jU6OjpYuHAh8+fP52tf+9o51XHVVVdx8803s3z5chYsWMANN9wwJO8DERl7hmLc9lh0JuvAWT/7+v75cyswzTnXaGbvAtYBxWf4WO8kZrcDtwMUFBScQVkiInImhmKdnFWrVvGP//iPLF++nOTkZBISEk7qPpmZmcmKFSuYP38+11xzDe9+97sH5dzf/OY3ue2221i4cCFJSUk8/PDDg/K8w2bhBwclsIUqLCxk9+7dJ+3/zne+w3e+852T9m/cuPGkfYmJifzXf/3XSfsvueQSLrnkEsCbefJjH/sY4M1IGaqrxQ3gzjvv5M477zyLVyAiMjTjtsciO9UMYABmthz4pnNujb99D4Bz7nuneMxBYCleiDurxwIsXbrUbd68+cxfhYjIOPLGG2+ctquiyEin97GI9LXi3heo6Ces5aUn8vLdl0Wgosgysy3OuaV9959JF8pNQLGZFZlZHHAj8HSfJ59sfr8ZM1vmP2/1mTxWRERERERkKMZtj0Wn7ULpnOs0szuA9UA08JBzbpeZfca//37gBuCzZtYJtAA3Oq9pr9/HDtFrERGRUei9730vBw4c6LXv+9//PmvWrIlQRSIiEgld3f3vW/8WlbUt5KYnctea2YM+DGC0O20XykhQF0oRkYG98cYbzJkz56Rp40VGC+ccb775prpQioicQjhdKEVEZARJSEigurq63+n0RUY65xzV1dUkJCREuhQRkVHpTGahFBGRESQ/P5/y8nKOHz8e6VJEzklCQgL5+eEvXi4iMh4pwImIjDKxsbEUFRVFugwRERGJAHWhFBERERERGSUU4EREREREREYJBTgREREREZFRYkQuI2Bmx4FDka6jH1lAVaSLGKd07SNL1z9ydO0jS9c/snT9I0fXPrJ0/SNnJF37ac657L47R2SAG6nMbHN/azHI0NO1jyxd/8jRtY8sXf/I0vWPHF37yNL1j5zRcO3VhVJERERERGSUUIATEREREREZJRTgzs4DkS5gHNO1jyxd/8jRtY8sXf/I0vWPHF37yNL1j5wRf+01Bk5ERERERGSUUAuciIiIiIjIKKEAJyIiIiIiMkoowJ0BM7vazN4ys71mdnek6xnrzGyqmb1oZm+Y2S4zu9Pf/00zqzCz7f7PuyJd61hkZgfNbId/jTf7+yaa2R/NrNT/NyPSdY5FZjY75P293czqzexv9d4fOmb2kJkdM7OdIfsGfL+b2T3+74K3zGxNZKoeGwa49veZ2ZtmVmJmvzazdH9/oZm1hPw/cH/kKh8bBrj+A37W6L0/eAa49r8Mue4HzWy7v1/v/UF2iu+Zo+azX2PgTsPMooE9wJVAObAJuMk5tzuihY1hZjYFmOKc22pmqcAWYC3wQaDROfdPES1wjDOzg8BS51xVyL4fACecc/f6f8TIcM59OVI1jgf+Z08FcBFwG3rvDwkzWw00Aj9zzs339/X7fjezucBjwDIgF/hfYJZzLhCh8ke1Aa79VcALzrlOM/s+gH/tC4Hfdh0n4Rvg+n+Tfj5r9N4fXP1d+z73/zNQ55z7lt77g+8U3zM/xij57FcL3OktA/Y65/Y759qBx4HrI1zTmOacO+Kc2+rfbgDeAPIiW9W4dz3wsH/7YbwPOhlalwP7nHOHIl3IWOacewk40Wf3QO/364HHnXNtzrkDwF683xFyDvq79s6555xznf7mq0D+sBc2Tgzw3h+I3vuD6FTX3swM7w/Wjw1rUePIKb5njprPfgW408sDDodsl6MwMWz8vzwtBv7q77rD71rzkLrxDRkHPGdmW8zsdn9fjnPuCHgffMCkiFU3ftxI71/geu8Pn4He7/p9MLw+DvwhZLvIzLaZ2Z/NbFWkihoH+vus0Xt/+KwCjjrnSkP26b0/RPp8zxw1n/0KcKdn/exTv9NhYGYpwJPA3zrn6oH/B8wAFgFHgH+OYHlj2Qrn3BLgGuDzflcPGUZmFge8B/gff5fe+yODfh8MEzP7KtAJPOLvOgIUOOcWA18CHjWzCZGqbwwb6LNG7/3hcxO9/3in9/4Q6ed75oCH9rMvou9/BbjTKwemhmznA5URqmXcMLNYvP+pHnHOPQXgnDvqnAs454LAf6PuG0PCOVfp/3sM+DXedT7q9xnv6jt+LHIVjgvXAFudc0dB7/0IGOj9rt8Hw8DMPgpcC9zi/IH6ftelav/2FmAfMCtyVY5Np/is0Xt/GJhZDPA+4Jdd+/TeHxr9fc9kFH32K8Cd3iag2MyK/L+K3wg8HeGaxjS///ePgTecc/8Ssn9KyGHvBXb2fayEx8yS/QG9mFkycBXedX4a+Kh/2EeB30SmwnGj119g9d4fdgO9358GbjSzeDMrAoqB1yJQ35hlZlcDXwbe45xrDtmf7U/sg5lNx7v2+yNT5dh1is8avfeHxxXAm8658q4deu8PvoG+ZzKKPvtjInny0cCfCesOYD0QDTzknNsV4bLGuhXAh4EdXdPoAl8BbjKzRXjN1geBT0emvDEtB/i199lGDPCoc+5ZM9sEPGFmnwDKgA9EsMYxzcyS8Ga9DX1//0Dv/aFhZo8BlwBZZlYOfAO4l37e7865XWb2BLAbr3vf5zUL37kb4NrfA8QDf/Q/h151zn0GWA18y8w6gQDwGefcmU7AIf0Y4Ppf0t9njd77g6u/a++c+zEnj30GvfeHwkDfM0fNZ7+WERARERERERkl1IVSRERERERklFCAExERERERGSUU4EREREREREYJBTgREREREZFRQgFORERERERklFCAExGRUc/MGv1/C83s5kF+7q/02X5lMJ9fRETkbCjAiYjIWFIInFWA61ok9xR6BTjn3DvOsiYREZFBowAnIiJjyb3AKjPbbmZfNLNoM7vPzDaZWYmZfRrAzC4xsxfN7FFgh79vnZltMbNdZna7v+9eINF/vkf8fV2tfeY/904z22FmHwp57j+Z2a/M7E0ze8T8ValFRETCFRPpAkRERAakLq2hAAAgAElEQVTR3cDfOeeuBfCDWJ1z7kIziwdeNrPn/GOXAfOdcwf87Y87506YWSKwycyedM7dbWZ3OOcW9XOu9wGLgPOBLP8xL/n3LQbmAZXAy8AKYOPgv1wRERlv1AInIiJj2VXAR8xsO/BXIBMo9u97LSS8AXzBzF4HXgWmhhw3kJXAY865gHPuKPBn4MKQ5y53zgWB7XhdO0VERMKmFjgRERnLDPgb59z6XjvNLgGa+mxfASx3zjWb2Z+AhDN47oG0hdwOoN+3IiIySNQCJyIiY0kDkBqyvR74rJnFApjZLDNL7udxaUCNH97mABeH3NfR9fg+XgI+5I+zywZWA68NyqsQEREZgP4iKCIiY0kJ0Ol3hfwp8EO87otb/YlEjgNr+3ncs8BnzKwEeAuvG2WXB4ASM9vqnLslZP+vgeXA64AD/o9z7m0/AIqIiAwJc85FugYRERERERE5A+pCKSIiIiIiMkoowImIiIiIiIwSCnAiIjJi+BOCNJpZwWAeKyIiMlZoDJyIiJwzM2sM2UzCmz4/4G9/2jn3yPBXJSIiMnYpwImIyKAws4PAJ51z/3uKY2Kcc53DV9XopOskIiIDURdKEREZMmb2HTP7pZk9ZmYNwK1mttzMXjWzWjM7Ymb/HrJOW4yZOTMr9Ld/4d//BzNrMLO/mFnR2R7r33+Nme0xszoz+w8ze9nMPjZA3QPW6N+/wMz+18xOmNnbZvZ/Qmr6mpntM7N6M9tsZrlmNtPMXJ9zbOw6v5l90sxe8s9zAvh7Mys2sxfNrNrMqszs52aWFvL4aWa2zsyO+/f/0MwS/JrPCzluipk1m1nmuf+XFBGRkUIBTkREhtp7gUfxFsv+JdAJ3AlkASuAq4FPn+LxNwNfAyYCZcC3z/ZYM5sEPAHc5Z/3ALDsFM8zYI1+iPpf4BlgCjAL+JP/uLuAG/zj04FPAq2nOE+odwBvANnA9wEDvuOfYy4w3X9tmFkM8DtgL946d1OBJ5xzrf7rvLXPNVnvnKs+wzpERGQEU4ATEZGhttE594xzLuica3HObXLO/dU51+mc24+3UPY7T/H4XznnNjvnOoBHgEXncOy1wHbn3G/8+/4VqBroSU5T43uAw865Hzrn2pxz9c651/z7Pgl8xTlX6r/e7c65E6e+PN3KnHP/zzkX8K/THufc8865dufcMb/mrhqW44XLLzvnmvzjX/bvexi42V+4HODDwM/PsAYRERnhYiJdgIiIjHmHQzfMbA7wz8AFeBOfxAB/PcXj3w653QyknMOxuaF1OOecmZUP9CSnqXEqXstXf6YC+05R36n0vU6TgX/HawFMxfuj6/GQ8xx0zgXowzn3spl1AivNrAYowGutExGRMUAtcCIiMtT6zpb1X8BOYKZzbgLwdbzugkPpCJDfteG3TuWd4vhT1XgYmDHA4wa6r8k/b1LIvsl9jul7nb6PN6vnAr+Gj/WpYZqZRQ9Qx8/wulF+GK9rZdsAx4mIyCijACciIsMtFagDmvzJNk41/m2w/BZYYmbX+ePH7sQba3YuNT4NFJjZHWYWZ2YTzKxrPN2DwHfMbIZ5FpnZRLyWwbfxJnGJNrPbgWmnqTkVL/jVmdlU4O9C7vsLUA1818ySzCzRzFaE3P9zvLF4N+OFORERGSMU4EREZLj9f8BHgQa8lq5fDvUJnXNHgQ8B/4IXfGYA2/BauM6qRudcHXAl8H7gGLCHnrFp9wHrgOeBeryxcwnOW7PnU8BX8MbezeTU3UYBvoE30UodXmh8MqSGTrxxfefhtcaV4QW2rvsPAjuAdufcK6c5j4iIjCJaB05ERMYdv+thJXCDc25DpOsZCmb2M2C/c+6bka5FREQGjyYxERGRccHMrsbretgK3IO3VMBrp3zQKGVm04HrgQWRrkVERAaXulCKiMh4sRLYj9eF8Wpg7Vic3MPMvge8DnzXOVcW6XpERGRwqQuliIiIiIjIKKEWOBERERERkVFiRI6By8rKcoWFhZEuQ0REREREJCK2bNlS5Zw7acmbERngCgsL2bx5c6TLEBERERERiQgzO9TffnWhFBERERERGSUU4EREREREREYJBTgREREREZFRQgFORERERERklFCAExERERERGSUU4EREREREREaJsAKcmV1tZm+Z2V4zu7uf+9PM7Bkze93MdpnZbeGcT0REREREZDCs21bBintfoOju37Hi3hdYt60i0iWdkXNeB87MooEfAVcC5cAmM3vaObc75LDPA7udc9eZWTbwlpk94pxrD6tqERERERGRc7RuWwX3PLWDlo4AABW1Ldzz1A4A1i7Oi2RppxVOC9wyYK9zbr8fyB4Hru9zjANSzcyAFOAE0BnGOUVERERERM6Kc46qxjZKymt5ducRvvH0zu7w1qWlI8B969+KUIVn7pxb4IA84HDIdjlwUZ9j/hN4GqgEUoEPOeeC/T2Zmd0O3A5QUFAQRlkiIiIiIjKeNLV1UlnbQmVdK5W1LRypbaGi1r9d5+1v7+w3hvRSWdsyDNWGJ5wAZ/3sc3221wDbgcuAGcAfzWyDc67+pAc69wDwAMDSpUv7Po+IiIiIiIxDHYEgR+tbqfQDWWVdix/SWqmobeFIXSt1LR29HhNlkDMhgSlpCczPS+OqeZPJTUsgNz2R3PREPvWzzRypaz3pXLnpicP1ss5ZOAGuHJgasp2P19IW6jbgXuecA/aa2QFgDvBaGOcVEREREZExwDnHiaZ2L5x1BbM6L5h1hbRjDa0E+zTvpCXGkpueSF56IhcWTvSDmRfQpqQlkDMhgdjogUeLffnqOb3GwAEkxkZz15rZQ/VSB004AW4TUGxmRUAFcCNwc59jyoDLgQ1mlgPMBvaHcU4RERERERklmts7u1vOjtT16dbo327r07UxLiaKPD+IrSzO6m45m5KeSF56AlPSEkmODyfG9ExUct/6t6isbSE3PZG71swe8ROYQBgBzjnXaWZ3AOuBaOAh59wuM/uMf//9wLeBn5rZDrwul192zlUNQt0iIiIiIhJBnYEgRxva/PFmXiA74reidbWo1Tb37tpoBpNS48lNT2TulAlccd4kv9XMa02bkp5AZnIc3hyIQ2vt4rxREdj6Ciu6Oud+D/y+z777Q25XAleFcw4RERERERlezjlqmzt6ujLWtfaaJKSytoWj9Sd3bZyQENM9zmzJtPSeYOa3ouVMSCAuJqylqMe98NoeRUREREQk4tZtqzir7oAt7QEq67wxZqETg4SORWvt6NO1MTqKKekJ5KYlsnxGph/MvLFneX4Xx5QwuzbK6ekKi4iIiIiMYv0tSn33kyUcqGpk5qTU7haz7in261o50dR+0vNMSo1nSnoicyancunsSf4kIQl+SEskMzmOqKih79oop6YAJyIiIiIySlU1tvHt3+4+aVHq1s4gP3x+b/d2anyMPxFIAudPTe/VrTE3LZGctHjiY6KHu3w5BwpwIiIiIiKjwImmdnZU1LGjvNb/t47KftYyC7X+b1czJT2BCQmxw1SlDDUFOBERERGREaauuYMdFXWUVNSys6KOkvI6ymtauu8vykpmaeFEFuancf+f91HVeHKXyLz0RGZPTh3OsmUYKMCJiIiIiERQfWsHO/0WtR0V3s+h6ubu+wsmJnH+1HQ+fPE0FuSlMS8vjbTEnha1rJT4UbsotZw9BTgRERERkWHS2NbJLj+klZTXsbOijv1VTd3356UnsjA/jQ9dOJUFeWksyEsjPSnulM85mhellrOnACciIiIiMgSa2zvZXVlPSUjL2r7jjTh/7bQpaQksyEvjfUvymO+HtcyU+HM612hdlFrOngKciIiIiEiYWjsC7D5Sz47ynpa10mMN3QtdZ6fGc35+GtctzGVhfhrz89LITj23sCbjmwKciIiIiMhZaOsM8OaRBkq6Z4SsZ8/RBgJ+WstKiWNBXhpr5k9mYV4aC/LTyJmQEOGqZaxQgBMRERERGUB7Z5A9Rxv8bpC1lJTXsedoAx0BL6xlJMWyID+dy+dMYkG+1w1ySloCZlrwWoaGApyIiIiICNARCFJ6tLE7qO2oqOPNIw20B4IATEiIYWF+Op9cNZ2FeV43yPyMRIU1GVYKcCIiIiIy7nQGguw73kSJvyh2SXkdu4/U097phbXU+Bjm56Vx24pCFuSnsTAvnakTFdYk8hTgRERERGRMCwQdB6oaKfEnGNlRUceuyjpaO7ywlhwXzby8ND5y8TQvrOWnM21iElFRCmsy8ijAiYiIiMiYEQw6DlY3dbeq7SivY2dlHc3t3iLXibHRzMudwE3LCliYn8aCvHSmZyUrrMmooQAnIiIiIiPOum0Vp12Y2jnHoerm7jXWSspr2VVRT0NbJwDxMVHMzZ3ABy7IZ0F+Ogvz05iRnUK0wpoAlDwBz38L6sohLR8u/zos/GCkqzotBTgRERERGVHWbavgnqd20NLhtZpV1LZwz1MlVDe1MSUtsXtGyB3lddS3emEtLjqK86akcv3iXBbmpbMgP42Zk1KIjY6K5EuRkarkCXjmC9DR4m3XHfa2YcSHOAU4ERERERlRvv/sm93hrUtLR5Bv//YNAGKjjdmTU3m3vyj2grw0ZuWkEhejsCanEeiE8k3wuy/1hLcuHS1ei5wCnIiIiIhIb3UtHRysauJgdRMHqpo4WNXEgepmDlU3UdvcMeDjnr5jBbMnpxIfEz2M1cqo1lIL+56HPeuh9DloqRn42Lry4avrHCnAiYiIiMiQaGzr9IJZd0Br8kNbMyea2nsdm5uWQGFWMu9aMIXfvl7Z3TUyVF56Igvz04erfBmtnIPqvbDnWS+0HXoFXACSMmHW1TBrDaz/KtRXnPzYtPzhr/csKcCJiIiIyDlrbu/kYFVzr5Y073YzVY1tvY7NmRBPYWYyV83NoTArmcLMZIqykpmWmURCbE+L2rLCib3GwIE3e+Rda2YP2+uSUaazHcpe8QLbnmfhxH5vf858WPm3XnDLuwCi/PdZoKP3GDiA2ERvIpMRTgFORERERE6ptSPAoepmL6D5rWhdt4/W9w5pWSnxFGUlcensbAqzvIBWmJlMYVYSSXFn9tWza7bJ081CKeNcUxWU/tELbPtegLZ6iI6HotWw/PNQvAbSp/b/2K5xbqNwFkpzzkW6hpMsXbrUbd68OdJliIiIiIwbbZ0BDp9o5kBVc+/ujlVNHKlvJfQr48TkOAozk7yAlpncHdSmZSaRmhAbuRchY5tzcHRXT9fI8k2Ag5TJXrfIWVfD9HdCXHKkKx0UZrbFObe07/6wWuDM7Grgh0A08KBz7t4+998F3BJyrvOAbOfciXDOKyIiIiJnryMQ5PCJ5u4ujqGTiFTWthAMCWlpibEUZiWzrGhin5a0ZNISFdJkmHS0wIENPaGt3p9kJHcJXHKPF9ymnA82ftb2O+cWODOLBvYAVwLlwCbgJufc7gGOvw74onPustM9t1rgRERERM5NZyBIRW1LyHi0nq6P5TUtBEJSWmp8jDcWLSuZIr9FratVLSM5LoKvQsa1+iNQut4LbPv/BB3NEJsMMy71AlvxVZA6OdJVDrmhaIFbBux1zu33T/A4cD3Qb4ADbgIeC+N8IiIiIgIEgo7K2paQ8WjN3bcP1zTTEegJaUlx0RRmJjM/N41rF07pnjikMCuZzOQ4bBy1XMgIFQzCkW09E5Aced3bn14Ai2/1Qtu0lRCbENk6R4hwAlwecDhkuxy4qL8DzSwJuBq4Y6AnM7PbgdsBCgoKwihLREREZORZt63irCblCAYdb9e39hqP1hXUyqqbaQ8Eu49NiI2iMDOZWTmpXDVvMkVZSd1BLTs1XiFNRp62Rtj/ot818jloOgYWBVMvgiu+6Y1ny54zrrpGnqlwAlx/V3Og/pjXAS+fauybc+4B4AHwulCGUZeIiIjIiLJuW0WvafEralu456kdOOd4x8ysk9dJq2rm0IkmWjt6QlpcTBTTJiZRlJXMZXMmdc/sWJSVTE5qAlFR+qIrI1zNQS+s7XkWDm6AQDvEp8HMy2H2NTDzCkiaGOkqR7xwAlw5EDovZz5QOcCxN6LukyIiIjJO3bf+rV5rmgG0dAT40hOv9/rrd2y0MXViEkWZyawszgqZ5TGJ3LREhTQZXQKd3kyRXROQHH/D259ZDMtu91rZCi6GaE2KczbCCXCbgGIzKwIq8ELazX0PMrM04J3ArWGcS0RERGRUCQYdu4/U81LpcSpqW/o9xgH/8J553UEtNz2BmOio4S1UZDC11MDe573AtveP3nZUDExbAUs+4o1ny5wR6SpHtXMOcM65TjO7A1iPt4zAQ865XWb2Gf/++/1D3ws855xrCrtaERERkRHseEMbG0qP89Ke42zcW0VVYzsAMVFGZ/DkESJ56Yl89B2Fw1ylyCByDqr39rSyHXoFXACSMmHWNV5gm3EpJKRFutIxI6x14Jxzvwd+32ff/X22fwr8NJzziIiIiIxEbZ0Bthys4aXSKl7ac5zdR+oBb6HrVcVZrC7OZlVxFq/sq+41Bg4gMTaau9bMjlTpIueusx3KXumZNfLEfm9/znxY+bde18i8CyAqOrJ1jlFhBTgRERGR8cQ5x4GqJl7ac5yXSqt4dX81ze0BYqKMJdMyuGvNbFYXZzMvd0Kv8Wpds02ezSyUIiNK43GvS+SeZ2HvC9DeANHxMP2dsPzzULwG0qee/nkkbApwIiIiIqdQ39rBK3ur+POeKjaUHqe8xhvPNi0zifcvyWf1rGyWz8gkJf7UX6vWLs5TYJPRwzk4usvvGvkslG8GHKRMhvnv82aNLFoNccmRrnTcUYATERERCREIOkrKa9ngd4vcdriWQNCREh/D8hmZfPqdM1hdnMW0TH1xlTGmowUObOgZz1Zf7u3PXQKX3OONZ5tyvtZmizAFOBERERn3jtS1sGFPFX8uPc7Le6uobe7ADObnpvGZd05ndXE2S6ZlEKsZImWsqa/0x7Kth/1/gs4WiE32Jh655G4ovgpScyJdpYRQgBMREZFxp7UjwF8PnPDGsu05TumxRgAmpcZz+ZwcVs/KYuXMLDJT4iNcqcggCwbhyLaeCUiOvO7tTy/omea/cCXE6L0/UinAiYiIyJjnnGPP0UZ/8pHjvHbgBG2dQeKio1hWNJEPLM1nVXE2cyanYuoeJqNRyRPw/LegrhzS8uHyr8PCD3r3tTXC/hf9rpHPQdMxsCiYehFc8U1v1sjsOeoaOUoowImIiMiYVNPUzsa93ji2DaVVvF3fCsDMSSncfFEBq2dlc3FRJolxmupcRrmSJ+CZL3hj2ADqDsPTf+MtqN10DA5uhEA7xKdB8RVeYJt5BSRNjGzdck4U4ERERGRM6AgE2X64trtbZElFHc7BhIQYVnatyTYrm7z0xEiXKjJ4gkH44zd6wluXzlYoeRwyi2HZ7d6skVMvgujYyNQpg0YBTkREREatwyea+fOe42woPc4re6tpaOskymDR1HTuvLyYVcXZnJ+fRowmH5HRrK0Rag9BzUGo6frX/6k95IW1fhn8zeZhK1OGhwKciIiIjBpNbZ28ur+6eyHtA1VNAOSmJfDuhVNYPSubFTOySEtSK4OMIsGANxtkaDDrCmc1B6HpeO/j4ydAxjTIngWzroJtv4CWmpOfNy1/yEuX4acAJyIiIiNWMOjYfaSel0q9bpFbDtXQEXAkxEZx8fRMPnzxNFbPymZGdrImH5GRraX25GDWvX0Ygh09x1o0pE+FjEKY/S7v39CfxIzeE45MXth7DBxAbKI3kYmMOQpwIiIiMqIcb2hjQ6k38ciG0uNUNbYDMGdyKh9fUcTqWdlcMC2DhFhNPiIjSKDDmzykVytaSFBrre19fOJEL4xNWQRz13otal0BbUI+RJ/F1/Su2SYHmoVSxhQFOBEREYmots4AWw7V8NIeb8bI3UfqAZiYHMfKmVmsnpXN6uIsJk1IiHClMq45B83Vfig7cHJQqy8HF+w5PjrOW1stoxDyl/aEs/RpXlhLSBvc+hZ+UIFtnFCAExERkWHlnONAVVP3OLZX91fT3B4gJspYMi2Du9bMZnVxNvNyJxAVpW6RMow6WqG2bOCuju2NvY9PyfFCWcHFJ3dzTJ0CUZo8RwafApyIiIgMufrWDl7ZW8Wf93jdIstrvLE60zKTeP+SfFYVZ7F8RiapCZp8RIaQc9B49OTJQrpa0Roqex8fk9gTyApX9e7mmF4AccnDWr4IKMCJiIjIOVq3rYL71r9FZW0LuemJ3LVmNmsX5wEQCDpKymvZUOp1i9x2uJZA0JEcF83yGVl8evV0Vs/KZlqmvgDLAEqeOLcxXWc15b7BhFwvkM24tE83x0JImdR7shCREUABTkRERM7aum0V3PPUDlo6AgBU1LZw95MlvLrfW4vt5b1V1DZ7s+otyEvjM++czuribJZMyyBWa7LJ6ZQ80XtWxbrD3jbA/PefPOV+aFfHvlPux6V6YSyrGIqv9ENakR/UpkJM/PC8JpFBYs65SNdwkqVLl7rNm7XooIiIyEi1/HvPc6Su/8WDs1PjWV2czepZWaycmUVmir4gy1n61/leaOsrKgawk6fcT8sPGX8W0s0xo+jkKfdFRgkz2+KcW9p3v1rgREREpF9NbZ0crG7iYFUzB6ubOFDVxMGqJg5WN3VP7d+XAa995XKtySbnrrWu//AGEOyElV/s3c0xLR+iNXZSxg8FOBERkXGspT3AoRNeMDtQ1ez9W+1tH2to63XspNR4CrOSuXxODn/YeYT61s6Tni83PVHhTc5eMAgHX4Jtv4A3nhn4uLSpcMU3h6sqkRFJAU5ERGSMa+0IcPhEs9eCVt0T1A5WN53UDTIrJY7CzGRWz8qmKCuZwsxkCrOSKMxMJjm+52vD8hmZvcbAASTGRnPXmtnD9rpkDKg5CNsfhe2PQV2ZtzbaolsgdTJs/JeeMXAAsYneRCYi45wCnIiIyBjQ3hnkcI3fguaHs4NVXmirrGshdMh7RlIshVnJLJ+eSWFWMoVZyRRlJjMtK4kJZziNf9dskwPNQikyoPZmeONpr7Xt4AbAvBkgr/gGzLkWYv0F2zMKz20WSpExLqxJTMzsauCHQDTwoHPu3n6OuQT4NyAWqHLOvfN0z6tJTERERE7WGQhSXtPS3cXR6+7ohbbymmaCIb/SJyTEeC1ofitaUUhQS0vSeCEZZs5B+SbY9nPY+Wtob/AC2qJb4fwbvdkgRaSXQZ/ExMyigR8BVwLlwCYze9o5tzvkmHTg/wJXO+fKzGzSuZ5PRERkPAgEHZW1LSHdHbsmDmnm8IlmOkNSWkp8DIVZSSzMT+P6Rbl+d0cvrGUkxWosmkRew9vw+mOw7RGoLoXYJJi7FhbfAgXvgCgtKSFytsLpQrkM2Ouc2w9gZo8D1wO7Q465GXjKOVcG4Jw7Fsb5RERExoRg0HGkvrW7u+OB7ta0Jg6faKYj0BPSkuKimZaZzHlTUrlm/uTugFaYmUxWSpxCmow8ne2w5w9eaNv7v+ACULAcVtwJ89ZCfGqkKxQZ1cIJcHlA6Byv5cBFfY6ZBcSa2Z+AVOCHzrmf9fdkZnY7cDtAQUFBGGWJiIhEnnOOt+tb/XDWMw3/oeomDlU309YZ7D42PiaKwsxkiielcOXcHIpCWtImpcYrpMno8PYOL7SV/BJaTkDqFC+0LboFsmZGujqRMSOcANffb5O+A+pigAuAy4FE4C9m9qpzbs9JD3TuAeAB8MbAhVGXiIjIOVm3reKsJuVwznG8oa3f2R0PVjfR2tET0uKioyjI9GZzfOes7O7xaIVZyUyekEBUlEKajELNJ2DH/3gTkrxdAtFxMPtdsPjD3sQkUdGRrlBkzAknwJUDoSNO84HKfo6pcs41AU1m9hJwPnBSgBMREYmkddsqek2LX1Hbwj1P7cA5x6pZ2f3O7niouomm9p5p9GOijIKJSRRmJfOOGVkUZSV1TyKSm55ItEKajAXBAOx7wQttb/0eAu0w5Xy45j5YcAMkTYx0hSJjWjgBbhNQbGZFQAVwI96Yt1C/Af7TzGKAOLwulv8axjlFRESGxH3r3+q1phlAS0eALz3xeq/uJdFRxtSMRAqzkllWNLHX7I656QnERGtSBhmjqvbC9l/A649DwxFInAhLP+FNSDJ5QaSrExk3zjnAOec6zewOYD3eMgIPOed2mdln/Pvvd869YWbPAiVAEG+pgZ2DUbiIiEg42juD7D5Sz5ZDNWwtq6GitqXf4xzw9Wvndge1/IxEYhXSZLxoa4Bdv/bGth1+FSwKZl4J1/wAZl0NMXGRrlBk3AlrHbihonXgRERksB2rb2VrWQ1by2rZeqiGHRV13ROJ5KYlUNPcTkvImLUueemJvHz3ZcNdrkjkOAeHXvZC2+510NEMWbO8yUjOvxFSJ0e6QpFxYdDXgRMRERmpOgJBdlfW9wpsXS1scdFRzM+bwIcvnsaSaRksKchgclrCSWPgABJjo7lrzexIvQyR4VV72FuzbfsjUHMQ4lJhwQe8CUnyl4JmQxUZERTgRERk1Dve0OaHtRq2HqqhpLyndW1KWgJLCjK4bUUhS6ZlMC93AvExJ8+M1zXb5NnMQiky6nW0wJu/8yYk2f8nwEHRarjkK3DedRCXFOkKRaQPdaEUEZFRpSMQ5M0jDT2BrayGwye81rXYaGNebhpLCjJYMi2dJQUZ5KYnRrhikRHGOajc6oW2HU9CWx2kFcCim2HRTZBRGOkKRQR1oRQRkVGqqrGNrYf8rpBlNZSU13avr5YzIZ4lBRl85OJClkxLZ15uGgmxWndKpF+Nx7xFtrc9AsffgJgEOO89sPhWKFwFUZqcR2Q0UIATEZERozMQ5M23G9hWVuPPDllL2YlmwGtdm5ubxk3LCvwWtgxy0xIwjcsRGVigA0qf80Jb6XoIdkL+hXDtv8H890FCWqQrFJGzpAAnIiIRc6Kp3W9dq/Fb1+po9tnAStQAACAASURBVBfGzk6NZ0lBOrdcVMAF0zKYn6fWNZEzdnS3NxlJyS+h6Tik5MDFn/Na27I1MY/IaKYAJyIiw6IzEOStow1sLatlmx/aDlZ7rWsxUcbc3Al8cOlUFhd4Y9fyMxLVuiZyNlpqYeevvNa2yq0QFQOzr4FFt8LMKyBaX/tExgL9nywiIkOipqmdbYdr2HrIG7v2+uFamvzWtayUOJYUZHCj3x1yQV4aiXFqXRM5a8EgHPiTF9reeAYCbZAzH9Z8DxZ+EJKzIl2hiAwyBTgREQlbIOjYc9SfGfJQLdvKathf1QRAdJRx3pRU3n9Bvjd2rSCDqRPVuiYSlhMHYPuj3k99OSSkw5KPeF0kp5yvNdtExjAFOBEROWt1zR1sPVzTPX7t9cN1NLZ1ApCZHMfiggxuWOoFtoX5aSTF6deNSNjam2D3b7zWtkMbAYOZl8NV34bZ74LYhEhXKCLDQL9RRUTklIJBR+mxxu5FsreW1bDvuNe6FmUwZ/IE1i7OZUlBBhdMy6BgYpJa10QGi3Nw+K/emm27fg3tjTBxOlz2NTj/JkjTQvMi440CnIiI9FLX0sG2Mm8K/21lNWwvq6XBb13LSIplSUEG71uSz+KCdM7PTyc5Xr9Kxq2SJ+D5b0FdOaTlw+Vf98ZdSfjqK+H1x7wuktV7ITYZ5r3X6yJZcLG6SIqMY/qtKyIyhq3bVsF969+israF3PRE7lozm7WLe/5iHww69h1v7B67tqWshr3HGgGvdW325Am8Z1Fu97prhZlqXRNfyRPwzBego8XbrjvsbYNC3LnqbIO3fu91kdz3PLggTFsBK78Ec6+H+JRIVygiI4ACnIjIGLVuWwX3PLWDlg5v5seK2hbufqqEN9+uJyE2mq1ltWwvq6G+1WtdS0+KZfHUdNb6gW3h1HRS1LomA3n+Wz3hrUtHCzx7N8SlQHQcRMdCTLz3b3QcRMeH7PPvj/ZvR0VF5nUMp4FaLI+87oW2HU9ASw1MyPNC26KbIXNGpKsWkRHGnHORruEkS5cudZs3b450GSIio9ry7z3PkbrWfu8zg9k5qSwuyGBJQTpLpmUwPStZrWtyZjrb4DuTBvc5Lbr/sBcdBzFx/r4+P937Q4Jgr4AY18++gY6N7XPOPrVERYfXbbFviyVAVKy3wHZ9uXeO866FRbfA9Eu884nIuGZmW5xzS/vu159WRURGuRNN7ZQebWDPsUb2Hm2g9Fgje442UtXYNuBjSr5xFakJscNYpYwJdRWw5Sew5acDH5MyGW7+JQTae34623tvB9oh0OEFwa7bgbY++zv87ZDbnW3eT1vDAM/vP09nGzDYf6C2foJd3MD7+gbP3etObrEMdkDTUXjXP8GCGyAxY5BrFpGxSAFORGQUcM5R3dTOnqMN7D3WSOnRxu7b1U3t3celxMcwc1IKl87OZv2ut7u7R4bKS09UeJMz5xwc3AivPQBv/s4blzXrasieDa/9V+9QEpvoTWmfuyhy9XYJBs4tIPa7v78Aeopg2lrX57wd3hIA/Ql0wrJPDe+1EZFRTQFORGQEcc5xvKGN0mONIa1qjZQea6CmuaP7uNSEGIonpXDFeTkU56RQnJNK8aQUpqQldHeDXDEzq9cYOIDE2GjuWjN72F+XjEJtjVDyS3jtv+H4G17r0PLPw4WfgIxC75iceSN3FsqoaIhLApIiXYnnX+d7E730lZY//LWIyKimACciEgHOOY7Wt1F6rIE9RxvZe6yB0qONlB5rpK6lJ6hNSIhhVk4qV8+fQvGkFIpzUpiVk8qk1PjTjlfrmm3yVLNQipykqhQ2PehNX99WD5MXwvU/gvnv91rYQi384MgJbCPd5V8/eQxcbKK3X0TkLCjAiYgMIecclXWtlIZ2fTzWwN6jjd1rq4G3vlpxTirXLvSC2qycVGbmpJCdcvqgdiprF+cpsMnpBQNQ+pzXTXLfC97kGvPWwrLbIf9CrTk2GLqC7khtsRSRUUMBTkRkEASDjoraFi+k+a1qpf6kIk3tPV0Ys1LimDkphbWL85iVk8LMSakU56SQlRIfwepl3Go+AVt/Bpt/DLVlkJoLl/49XPBRSBnkWSZFLZYiMigU4EREzkIw6CivaQkJaV7L2t5jjTSHBLXs1HiKJ6XwgaVTmTkpxe/+mMrE5LgIVi/iq9zujW3b+SvobIVpK+HKb8Ocd3uzKYqIyIgVVoAzs6uBHwLRwIPOuXv73H8J8BvggL/rKefct8I5p4jIcAgEHYdPNLPHn5Z/7zFv1sd9xxtp7Qh2H5czIZ5ZOal86MKpFE9K9VvVUkhPUlCTEaazHXb/xusmWf4axCZ5C0Vf+CnImRvp6kRE5Aydc4Azs2jgR8CVQDmwycyeds7t7nPoBufctWHUKCIyZDoDQQ6daKbUn0ikq+vjvuONtHf2BLXctARm5qRy8fTM7q6PMyelkJao1goZ4brXbnsYmo7BxBlw9b1w/k2QmB7p6kRE5CyF0wK3DNjrnNsPYGaPA9cDfQOciEjEdQSCHKpu8tdP6+n6uP94E+2BnqCWl55IcU4Kq4qzurs+zpyUonXTZHRxDg697LW2vfHbnrXbln0Kpl8KUVGRrlBERM5ROAEuDwhd0KQcuKif45ab2etAJfB3zrldYZxTRMa5ddsqTjktfntnkANVTZT60/J3dX08UNVEZ9B1Hzd1YiKzJqXyztnZ3V0fZ2SnkByvocEyivVduy0h/eS120REZFQL55tKf3MKuz7bW4FpzrlGM3sXsA4o7vfJzG4HbgcoKCgIoywRGavWbavotTB1RW0Ld/3qdf6woxKzKEqPNXCwupmAH9TMYNrEJGZOSuWKuTnMykmheFIq07OTSYpTUJMxpGqvv3bbIz1rt73nP7212+JGyELWIiIyKML5BlMOTA3ZzsdrZevmnKsPuf17M/u/ZpblnKvq+2TOuQeABwCWLl3aNwiKiPCD9W92h7cuHQHH+t3HmJ6VzMxJKVwzfwrF/kQiM7JTSIiNjlC1IkNMa7eJiIxL4QS4TUCxmRUBFcCNwM2hB5jZZOCoc86Z2TIgCqgO45wiMg7VNXfw2KYyKmtb+73fgBf+7pJhrUkkYppPwLafey1utWWQOgUu/Sos+Sik5kS6OhERGWLnHOCcc51mdgewHm8ZgYecc7vM7DP+/fcDNwCfNbNOoAW40Tmn1jUROSOHqpv4ycsHeWLzYZrbA8THRNEWMjNkl9z0xAhUJzLMtHabiIgQ5jpwzrnfA7/vs+/+kNv/CfxnOOcQkfHFOcfmQzU8uGE/z+0+SkyUcd35uXxy5XT2HG3oNQYOIDE2mrvWzI5gxSJDqL+1286/yZtNMmdepKsTEZEI0Ch+ERkROgNBfr/zbX68YT+vl9eRlhjL5y6ZwUeWF5IzIQGAubkTAE45C6XImFBfCZt/Alt+qrXbRESkFwU4EYmo+tYOfvnaYX76ykEqalsoykrm22vn8/4lef3OFLl2cZ4Cm4xN/a7dtsZfu+0yrd0mIiKAApyIRMjhE8385OWD/HJTGU3tAS6ePpF/eM88LpsziagozZ4n40hbI+x4whvfdmy31m4TEZFTUoATkWG1tcwb3/bszreJMuPahVP4xMrpLMhPi3RpIsNLa7eJiMg5UIATkSHXGQjy3O6jPLhhP1vLapmQEMPtq2fw0XdMY0qaZpCUcSQYgNI/+mu3Pa+120RE5KwpwInIkGlo7eCJzeX85OUDlNe0UDAxiX94zzxuuCCf5Hh9/Mg4orXbRERkkOgblIgMuoraFn768gEef+0wDW2dXFiYwd+/ey5Xzs0hWuPbZDyp3A6b/ht2hK7d9i2Yc63WbhMRkXOiACcig+b1w7U8uPEAv99xBIB3LZjCJ1YWsWiqpj2XcURrt4mIyBBSgBORsASCjj/uPsqPN+5n08EaUuNj+MTKIj76jkLy0jW+TcaR/tZuW/M9WHSz1m4TEZFBowAnIuekqa2T/9l8mIdePkjZiWbyMxL52rVz+dCFU0nR+DYZL7R2m4iIDDN9yxKRs3KkroWHXznEo389RH1rJ0sK0rn7mjlcNTeHmGh9WZVxot+12z4HSz8BE4siXZ2IiIxhCnAickZ2VtTx4Ib9/LbkCEHnuGb+FD6+sogLpmVEujSR4VO9z5tJctsj0FYHkxdo7TYRERlWCnAiMqBg0PH8m8d4cMN+/nrgBMlx0XxkeSG3rShk6kR9WZUxqOQJeP5bUFcOaflw+de9cNZ37ba513trt01dprXbRERkWJlzLtI1nGTp0qVu8+bNkS5DZNxqbu/kya0VPLTxAAeqmshNS+C2FUV8aNlUJiRo6nMZo0qegGe+AB0tPfuiYiF+ArRUe2u3Lf241m4TEZFhYWZbnHNL++5XC5yIdDta38rP/nKQR/5aRm1zB+fnp/EfNy3m6vmTidX4Nhnrnv9W7/AGEOyA9kb4wE+1dpuIiIwICnAiwu7Keh7cuJ9nXq+kM+i4am4On1w1naXTMjB1D5OxqLMNjr8FR3fC0V3w9g6oO9z/sYF2mPfe4a1PRERkAApwIuNUMOj4857jPLhxPy/vrSYpLppbLprGbSsKmZaZHOnyRAaHc9B4FN7e6Yc1P7BV7YFgp3dMTAJMOg9ik6Gj6eTnSMsf3ppFREROQQFOZJxp7Qjw1NYKfrxxP/uONzF5QgJ3XzOHmy4sIC1J3cNkFOtsg+Nv+i1qIYGtubrnmAn5kDMPZl/j/ZuzACZOh+iY/sfAxSZ6E5mIiIiMEApwIuPEsYZWfvGXQ/zir2WcaGpnft4E/u1Di3j3wika3yajS3+tam/v9FrVXMA7pqtVbfa7IGc+TJ4Pk+ZC0sSBn3fhB71/+85C2bVfRERkBFCAExnj3nq7gQc37Oc32yvpCAa5fE4On1xVxEVFEzW+TUa+M21Vmzwf5vhhLWc+ZM6AqOizP9/CDyqwiYjIiKYAJzIGOed4qbSKBzfsZ0NpFQmxUXzowqnctqKQ6dkpkS5P5GTOQcPbXlA7uqMnsA3UqjZ5gd8Fch4kajF5EREZPxTgRMaQ1o4Av9lewY83HmDP0UYmpcZz15rZ3LysgIzkuEiXJ+LpaIWqt/wWtZDAFtqqljbVC2dz3u0HtTBa1URERMYQBTiRMaC6sY1fvFrGz189SFVjO+dNmcA/f+B8rjs/l7gYjW+TCOluVQsZp9Y1A2R3q1qi16o259093R9z5qpVTUREZABhBTgzuxr4IRANPOicu3eA4y4EXgU+5Jz7VTjnFJEee4818OONB3hyawXtnUEumzOJT64sYvmMTI1vk+HV0dozVi00sLWc6Dmmb6vaZH8GSLWqiYiInLFzDnBmFg38CLgSKAc2mdnTzrnd/Rz3fWB9OIWKiMc5xyv7qvnvDfv501vHiY+J4v1L8vnEyiJmTtL4NhlizkHDkZ7Fr7sCW1Xpya1q512rVjUREZFBFk4L3DJgr3NuP4CZPQ5cD+zuc9zfAE8CF4ZxLpFxr60zwDOvH+HBDft58+0GslLi+NKVs7jlogIyU+IjXZ6MRd2tajt7B7aTWtXmw5xrvZkgc+arVU1ERGQIhRPg8oDDIdvlwEWhB5hZHvBe4DJOE+DM7HbgdoCCgoIwyhIZW2qa2nnkr4d4+C+HON7QxuycVH5ww0Lec34uCbH6kiynUfLE6dc162pVC52m/+iuk1vVcub6rWqhM0CmD/9rEhERGcfCCXD9DbBxfbb/Dfiycy5wuvE4zrkHgAcAli5d2vd5RMadfccbeWjjAZ7cWk5rR5DVs7L55w8Usao4S+Pb5MyUPAHPfAE6WrztusPw9Beg5iBMyO0d2Fpqeh6XVuCFs/Ou84PaAphYpFY1ERGRESCcAFcOTA3Zzgcq+xyzFHjc/7KZBbzLzDqdc+vCOK/ImLJuWwX3rX+LytoWctMTWLs4jzePNPD8m8eIi4nivYvy+PjKImZPTo10qTKSdbZ7ISz05w9f7glv3ce1wIv/6N3ublV7j9f1cfJ8mDRXrWoiIiIjWDgBbhNQbGZFQAVwI3Bz6AHOuaKu22b2U+C3Cm8iPdZtq+Cep3bQ0uF1U6uobeVHL+4jOS6aOy8v5taLp5GdqvFt44ZzXuDqG8QG/Kntud3RdHbnumOLWtVERERGoXMOcM65TjO7A292yWjgIefcLjP7jH///YNUo8iYVNfSwT88s6s7vIVKS4zli1fOikBVMiicg7b6MwtefbcDbQM/7//P3p3HR1me+x//XAkhCQESIATIAmFHhRD2AoKAC1o3tO77UnGpR+1pPdXTX5VaW63ao/WcWqV1LS51Bdw3VMQNguwKyCYkAUICCQlkn/v3xzMJk5BAyMJk+b5fr7wy88yTZ66Jo843931fd2h7r5NjxVdMEvRK8d+PqfpYZBd48WJvbVt10UkQO6DpXr+IiIg0mQbtA+ecewd4p9qxGoObc+6qhjyXSEvnnGNDVgEL1maxYG0WS3/cQ5mv5uWe2/OKjnJ1UiNfORTlHcGIWEAgcwcH80phUQFBKwZiBx4cvmoKZWEd4EjWP558T9U1cABhkV4jExEREWmRGhTgROTQikrL+WpTDp/4Q1v6Hu+D9JCenZg5uR8vp20ju6DkoJ+Lj4k82qW2HHXpqlhdWXENo16H+SrK9cLboYRHVw1Z0Um1BLFqoazdUZoWW/F7OdLfl4iIiDRbCnAijSwzt5BP1mXxydosvtiQQ2FpORFhIUzsH8uNU/ozdXBcZUAb1KNTlTVwAJFhodw+fXCwym/eauqqOO8mWPcuxPSu3/owC6kasDrGQffBVY9F1DA9MSIaQlvAf0JTLlBgExERaUVawKcPkeat3OdYtnVP5dTItTvyAUjsEsn5oxOZOiSO8f261bhn24wRCQABXSgjuX364MrjgjeNcedq+PEr+GiW10UxUHkprHn9yNeHVXy17wQhIUF5aSIiIiJHSgFOpB5y95fw2fpdLFibxWfrd5G7v5TQEGN0ny7cedoQpg2JY0Bcxzrt1zZjRIICW6CS/ZCxFLZ+5X1tWwIl+Yf5IYP/l3Vk68NEREREWiAFOJE6cM6xdkc+C9Z6UyO/3boHn4NuUe2ZNiSOaUPimDSwO9GRYcEuteXZlwPbvoYfv4StX8P25eArA8zbk2z4hdB7PCSNg6dP86ZNVhedqPAmIiIibYICnEgtCkvK+WJDNgvWZfHp2iwy/Z0hhyZ05uapA5g6JI7hiTGEhCg41JlzsGeLF9S2+gNb9nrvsdD2kDAKJtziD2xjvCmOgU68S10VRUREpE1TgBMJsG33fj5Z561l+3JjDiVlPqLah3L8wFhuPWkgUwbH0aNzRLDLbDkC169t/coLbAU7vMcioiHpJ5B6iRfYeqVC2GF+t+qqKCIiIm2cApy0aaXlPpb+uKeyzf8PWQUA9I2N4rJxfZg2JI4xfbsQ3u7gBiRSg0OtX4tOgr6TvLDWezx0H1K/5iHqqigiIiJtmAKctDk5BcV8um4XC9ZlsXD9LvKLyggLNcb17cZFY3szbUgcfWOjgl1my1Cxfm3rV94oW/X1aykXQJ8J3vq1mKRgVysiIiLS4inASavnnGNN5t7KNv8r0nNxDrp3Cue0oT2ZNqQHxw+MpWO4/nU4pCrr1/wjbAetX/sP6D2h5vVrIiIiItJg+sQqrVJBcRmLfsjmk7VZfLIui6z8YswgJTGG204cxLQhcRwX31kNSA6lYv3a1oAOkdXXrw2/2Bthq8v6NRERERFpMAU4aTW2ZO/jY3+b/8Wbd1NS7qNTeDsmD+rO1CFxTBncndiO4cEus/mqXL/m7xBZ4/q1n3gjbPVdvyYiIiIiDaIAJy1WSZmPJVt2V+7Ntil7HwAD4jpy1cRkpg6OY3RyF8JCFTRqVJf1a73He6FN69dEREREmgUFOGlRsvKL+HTtLhaszWLRhmwKisto3y6E8f26ceWEZKYNiSOpa4dgl9n81Hn92nhIGqv1ayIiIiLNlAKcNGs+n2NlRl7lKNuqjDwAekVHcFZqPNMGxzFhQDc6tNdbuYq6rl/rPR7iR2j9moiIiEgLoU+90uzsLSrl8/XZLFibxWfrs8guKCHEYGTvLtw+fTDThsQxpGcnzNSApFKV9WtfwbbFtaxfGw/dj9H6NREREZEWSgFOgs45x8ZdBZVt/tO27KHM54jpEMYJg7ozdXAcJwzqTpeo9sEutfkIXL+29WvIXA6+UrR+TURERKR1U4CToCgqLefrTTl8sjaLBeuy2La7EIAhPTtx3eR+nDgkjtSkGNq1hQYkK1+Gj++BvHSIToQT7/ICWIWD1q99DdnrvMcq16/drPVrIiIiIm2AApw0urnLMnjw/XVk5hYSHxPJ7dMHM2NEAtvzCvnE34Dkiw3ZFJaWExEWwsT+sVw/uT9Th8SREBMZ7PKPrpUvw5u3QKkXYMnb5t3P3QrhnQ4Etvzt3uOV69cu0vo1ERERkTbInHPBruEgo0ePdmlpacEuQ+ph7rIM7nx9FYWl5ZXH2oUYcZ3CycwrAiCxSyTThsQxdUgc4/t1IyIsNFjlBt/Dx3kjb7XpnAh9xmv9moiIiEgbY2ZLnXOjqx/XCJw0qgffX1clvAGU+RzZBSXcedoQpg2JY0Bcx7bVgKRknzcFcvdm2LO56vdDhbfbVmv9moiIiIhUoQAnjSozt7DG46XlPq4/of9RruYocQ72ZR8czvZs9oJbwc6q50fEQNe+EJ8K+7OhOP/ga0YnKbyJiIiIyEEaFODM7FTgr0Ao8E/n3P3VHj8b+APgA8qA25xzixrynNJ8rdiWi5mXZ6qLb+lr28rLvPVpB4W0H73bJQUBJxt0TvBC2sCToUtf73bF98AmI9XXwAGERXqNTEREREREqql3gDOzUOBvwMlAOrDEzOY7574LOO1jYL5zzplZCvAyMKQhBUvz9N7q7dz27+VER4axv6Sc4jJf5WORYaHcPn1wEKuro5J91cLZloCpjtvAV3bg3NBw6NLHC2XJE6uGtJjedW8sUtFt8lBdKEVERERE/BoyAjcW2OCc2wRgZi8BZwOVAc45FzgsEQU0v44p0iDOOWYv3MT9760lNSmG2ZeP5osN2TV2oQw652DfroPDWcX3fVlVz6+c6jgChp5bNaR16tV4zURSLlBgExEREZE6aUiASwC2BdxPB8ZVP8nMzgHuA+KA02u7mJnNBGYC9O7duwFlydFSWu7jrnmreXHxNk5P6cVfzh9ORFgoM0YkBC+wlZdB3tYamoZs8b5qm+o4aHrVaY5dkrWfmoiIiIg0Ow0JcDW1ETxohM059wbwhplNxlsPd1JNF3POzQZmg7eNQAPqkqMgr7CUXzz/LYs2ZPOLqf351cmDCQk5Sp0liwtqHkHbsxlyt4EL6IIZGu6Fsa59IXlS1ZAW0xvahR+dmkVEREREGkFDAlw6ENgmLxHIrO1k59xCM+tvZrHOuewGPK8E2bbd+7nmmSVszt7HA+elcMHoRu6WWGWqYw0hbd+uqudHdvFCWcIoGHregZDWJblxpzqKiIiIiARZQwLcEmCgmfUFMoCLgEsCTzCzAcBGfxOTkUB7IKcBzylB9u3WPVz3bBql5T6eu3YsE/rHHnzSypcP35SjvNRrDFJ9mmPF99J9ASebd50uyTD4tKrTHLv0hciYJnu9IiIiIiLNSb0DnHOuzMxuBt7H20bgKefcGjO7wf/448DPgCvMrBQoBC50rqYm89ISvLUyk1+9vIKe0RE8ddUY+nfvePBJ1dvi522Deb+A9e9BeOcDe6NVn+rYLuJAIOt3woHbmuooIiIiIlLJmmOeGj16tEtLSwt2GeLnnOOxTzfy4PvrGN2nC7OvGE3XqPY1n/zwUC+01SSy68GNQipud+ypqY4iIiIiIn5mttQ5N7r68QZt5C2tX0mZj9++sYpXlqZzdmo8f/5ZChFhoTWfnL+j9vCGwW82N1mdIiIiIiJtgQKc1Cpvfyk3zFnKV5tyuPXEgdx20kDMaug06fPBsufgg7tqv1h0YtMVKiIiIiLSRijASY1+zNnH1c8sIX13IQ9fOJxzRtQSwHath7dugx+/8Nr0D5wOn/7xwBo4gLBIr5GJiIiIiIg0iAKcHCRty26uey4NB8z5+TjG9u168EllJfDFI7DwQQjrAGf9H4y4DMygU4/Dd6EUEREREZEjpgAnVcxbnsHtr6wkoUskT101hr6xUQeftG0xzL8Fdn0Px50Lp/0ZOsYdeDzlAgU2EREREZEmoAAngNdp8tGPN/DwR+sZ27crT1w2ii7VO00W7YWPfw9LnoTOCXDJyzBoenAKFhERERFpgxTghOKycu54bRVvLMvg3JEJ3HfuMMLbVes0ufZtePvXkL8dxt0A0/4fhNewD5yIiIiIiDQZBbg2bs++Eq7/11IWb9nNr04exM3TBlTtNLl3O7z7X/D9fIg7Di6cA4mjglewiIiIiEgbpgDXhm3aVcA1zywhM6+Iv16UytmpCQce9Png22fgw1lQVuQ1IplwC4SGBatcEREREZE2TwGujfp6Uw43zFlKiBkvXjeOUX0COk3uWg9v3gpbv4S+k+GMR6Bb/+AVKyIiIiIigAJcm/Ta0nTueH0lvbt24KmrxtCnm7/TZFkxLHoYPv+LtzXA2X+D1Eu9rQFERERERCToFODaEOccD3+4nkcXbGBC/278/dJRRHfwT4nc+rW3NUD2Ohh6Hpx6X9WtAUREREREJOgU4NqIotJybn91JW+uyOSC0YncO2MY7duFQFEefPR7SHsSopPgkldg0CnBLldERERERGqgANcG5BQUM/NfS1n64x5+c+oQbjihn9dp8vs34Z3boWAn/OQmmPpbbQ0gIiIiItKMKcC1chuyvE6TO/cW8dilI/npsF7e1gDv/BrWvgU9hsFFz0OCtgYQEREREWnuFOBasS83ZHPDnKW0bxfCSzN/wojEaFjyJHw0C8pL4KRZMP5mbQ0gIiIijhhoXAAAIABJREFUItJCKMC1Ui8v2cZ/v7GKvrFRPHXVGJLKtsLTF8G2r6HvCXDGw9oaQERERESkhVGAa2V8PseDH6zj759uZNLAWP524XF0XvJXb2uA8I4w4+8w/GJtDSAiIiIi0gIpwLUiRaXl/OfLy3ln1Q4uGdebe1L30u6ZqZC9HoadD9Pvg47dg12miIiIiIjUkwJcK7Erv5ifP5fGyvRcZp2SyJX7nsSefRqie8Olr8LAk4NdooiIiIiINJACXCuwfmc+Vz+9hJx9xbw+JYcR3/4n7MvyGpRM/W9oHxXsEkVEREREpBEowLVwn/+wi5vmfEtSWC7v9HuN6K/eh57D4OIXIWFksMsTEREREZFGpADXgr3wzVbumreS26I/56byOYRklMPJ93ibcmtrABERERGRVqdBAc7MTgX+CoQC/3TO3V/t8UuB3/jvFgA3OudWNOQ5xes0ed+73/Ppos95t/MzDCz8DvpN8bYG6Nov2OWJiIiIiEgTqXeAM7NQ4G/AyUA6sMTM5jvnvgs4bTNwgnNuj5mdBswGxjWk4LZuf0kZv35xMYN/mM27EW8SGtIZZjwOwy/S1gAiIiIiIq1cQ0bgxgIbnHObAMzsJeBsoDLAOee+DDj/ayCxAc/X5mXtLeIv/3yGX+U+Qv9222HYhTD9TxAVG+zSRERERETkKGhIgEsAtgXcT+fQo2vXAu/W9qCZzQRmAvTu3bsBZbVO67Zs4/vnfsmffR9S2CkRznkNBpwU7LJEREREROQoakiAq2m+nqvxRLOpeAHu+Nou5pybjTfFktGjR9d4nTbJOVZ/9Bw9Ft3FmbaX7GEziT1zlrYGEBERERFpgxoS4NKBpID7iUBm9ZPMLAX4J3Cacy6nAc/X9uRlsG3OTQzd9Skb2vXHLnyF2EFjg12ViIiIiIgESUgDfnYJMNDM+ppZe+AiYH7gCWbWG3gduNw5t74Bz9W2+Mrxff0ExX8dTWzWl7zcdSa9fv2lwpuIiIiISBtX7xE451yZmd0MvI+3jcBTzrk1ZnaD//HHgbuAbsBj5nVILHPOjW542a3Yzu8on/cfhGam8U35MJYPv5tfnHsSoSHqMCkiIiIi0taZc81vudno0aNdWlpasMs4ukqL4POHcIseYa+LZFbJZYw8fSaXT+gb7MpEREREROQoM7OlNQ1+NWgjb2kkWxbBm7dCzgbeDTmBP5Zfxr1XTGHq4LhgVyYiIiIiIs2IAlwwFe6BD++Cb59jf1Qi/+H7Ld+Hj+LJ68ZwTK/Owa5ORERERESaGQW4YHAOvpsL7/wXbn8Oq/pcyYXrpzAgPo65V44mrnNEsCsUEREREZFmSAHuaMtLh7d/Bevfw/Uczt8T/8wDK8KZflwPHr4wlQ7t9Y9ERERERERqprRwtPjKYck/4eN7wPkomnYPN20Yy4IVu5k5uR93nDqEEHWaFBERERGRQ1CAOxp2roH5t0BGGvQ/kR2T/8RVb2TxQ9Ye/nTOMC4Z1zvYFYqIiIiISAugANeUSotg4QPwxV8hIhrO/Qcru5zMtc8tpaiknGeuHsOkgd2DXaWIiIiIiLQQCnBNZfPn3tYAuzfC8Etg+h95b1MJt83+mm5R4Tx/0zgG9egU7CpFRERERKQFUYBrbPt3e1sDLPsXdEmGy+fi+k3hH59v4r531zI8MYZ/XDGa7p3Cg12piIiIiIi0MApwjcU5WPM6vPsbL8RNvA1O+A2loRHc9cZqXly8ldOH9eIvFwwnIiw02NWKiIiIiEgLpADXGHK3eVsD/PA+xI+Ay16HXinsLSrlF/9awuc/ZHPTlP78+pTB6jQpIg1WWlpKeno6RUVFwS5FpF4iIiJITEwkLCws2KWIiLQ4CnAN4SuHxbPh4z8ADqb/CcZeD6Ht2LZ7P9c8s4TN2ft44GcpXDAmKdjVikgrkZ6eTqdOnUhOTsZMfxSSlsU5R05ODunp6fTt2zfY5YiItDgKcPW1YzW8eQtkLIUBJ8Hp/wNd+gCwbOsernsujZIyH89dM5YJA2KDXKyItCZFRUUKb9JimRndunVj165dwS5FRKRFUoCri5Uvextw56VD5wToOQw2fAgRMfCzJ2Hoz8D/QeqdVdv55b+X06NzBC/NHMOAuI5BLl5EWiOFN2nJ9P4VEak/BbjDWfmyN9JWWujd35vuffWeABc9Dx26At6UkL9/tpEH3lvHqD5dmH35KLp1VKdJERERERFpPCHBLqDZ+/ieA+EtUN62yvBWUubjN6+t5IH31nHm8Hie//k4hTcRETlqtmzZwtChQ5vk2p9++ilnnHEGAPPnz+f+++9vkucREZG6UYA7nLz0Qx7P21/KVU8v5uW0dG6ZNoBHL0rVNgEi0qzMXZbBxPsX0PeOt5l4/wLmLsto0uf76U9/Sm5uLrm5uTz22GOVxwODQJu28mV4eCjMivG+r3w52BXV2VlnncUdd9wR7DJERNo0BbjDiU6s9fiPOfs45+9fsGTLbv5y/nD+85TBmtcvIs3K3GUZ3Pn6KjJyC3FARm4hd76+qklD3DvvvENMTMxBAe5oKisrC8rzHlbFtPy8bYDzvr95S6OEuLKyMq688kpSUlI477zz2L9/P/fccw9jxoxh6NChzJw5E+ccAI8++ijHHnssKSkpXHTRRQDs27ePa665hjFjxjBixAjmzZt30HM888wz3HzzzQBcddVV3HLLLUyYMIF+/frx6quvVp734IMPMmbMGFJSUrj77rsb/NpEROQArYE7nBPvqroGDiAskk0p/8l5j31Juc/xr2vH8ZN+3YJXo4i0Wb9/cw3fZe6t9fFlW3MpKfdVOVZYWs5/vbqSFxdvrfFnjo3vzN1nHlfrNR944AEiIiK45ZZb+OUvf8mKFStYsGABH3/8MU8//TSLFi0iLS2NO+64g40bN5KamsrJJ5/M6aefTkFBAeeddx6rV69m1KhRzJkzp9Y/fCUnJ3PllVfy5ptvUlpayiuvvMKQIUPYvXs311xzDZs2baJDhw7Mnj2blJQUZs2aRWZmJlu2bCE2NpZTTjmFuXPnUl5ezurVq/nVr35FSUkJ//rXvwgPD+edd96ha9eudfgtH4F374Adq2p/PH0JlBdXPVZaCPNuhqXP1vwzPYfBaYeftrhu3TqefPJJJk6cyDXXXMNjjz3GzTffzF133QXA5ZdfzltvvcWZZ57J/fffz+bNmwkPDyc3NxeAP/7xj0ybNo2nnnqK3Nxcxo4dy0knnXTI59y+fTuLFi1i7dq1nHXWWZx33nl88MEH/PDDDyxevBjnHGeddRYLFy5k8uTJh30NIiJyeBqBO5yUC+DMRyE6CTCITiIt5fec+kkvOke0442bJii8iUizVT28He54XUyePJnPP/8cgLS0NAoKCigtLWXRokVMmjSp8rz777+f/v37s3z5ch588EEAli1bxiOPPMJ3333Hpk2b+OKLLw75XLGxsXz77bfceOONPPTQQwDcfffdjBgxgpUrV/KnP/2JK664ovL8pUuXMm/ePF544QUAVq9ezQsvvMDixYv57W9/S4cOHVi2bBnjx4/nueeeq/fvoN6qh7fDHT8CSUlJTJw4EYDLLruMRYsW8cknnzBu3DiGDRvGggULWLNmDQApKSlceumlzJkzh3btvL/lfvDBB9x///2kpqYyZcoUioqK2Lq15pBfYcaMGYSEhHDssceyc+fOyut88MEHjBgxgpEjR7J27Vp++OGHBr8+ERHxaASuDuaWT+TB4kfJLCqkI+3I/6KMsckxPHH5KLpEtQ92eSLShh1qpAxg4v0LyMg9uBFTQkwk/75+fL2ec9SoUSxdupT8/HzCw8MZOXIkaWlpfP755zz66KPcd999tf7s2LFjSUz0pqanpqayZcsWjj/++FrPP/fccyuf8/XXXwdg0aJFvPbaawBMmzaNnJwc8vLyAG+NVmRkZOXPT506lU6dOtGpUyeio6M588wzARg2bBgrV66s1+s/pMONlD081D99sproJLj67QY9dfWRTDPjpptuIi0tjaSkJGbNmkVRUREAb7/9NgsXLmT+/Pn84Q9/YM2aNTjneO211xg8eHCV61QEs5qEhx9o2FUxPdM5x5133sn111/foNcjIiI10wjcYVRfP5JfVEaoGReMTlR4E5Fm7/bpg4ms1lgpMiyU26cPruUnDi8sLIzk5GSefvppJkyYwKRJk/jkk0/YuHEjxxxzzCF/NvADf2ho6GHXqlWcH3huRVAIVBFeoqKian2+kJCQyvshISHBWSd34l0QFln1WFikd7yBtm7dyldffQXAiy++WBmMY2NjKSgoqFyj5vP52LZtG1OnTuWBBx4gNzeXgoICpk+fzv/+7/9W/n6XLVtWrzqmT5/OU089RUFBAQAZGRlkZWU19OWJiIhfgwKcmZ1qZuvMbIOZHdSWysyGmNlXZlZsZr9uyHMFy4Pvr6OwtLzKsXLnePgjTQcRkeZvxogE7jt3GAkxkRjeyNt95w5jxoiEBl138uTJPPTQQ0yePJlJkybx+OOPk5qaWmUUqFOnTuTn5zfwFdT83M8//zzgdbaMjY2lc+fOjf48TaKGafmc+ah3vIGOOeYYnn32WVJSUti9ezc33ngj1113HcOGDWPGjBmMGTMGgPLyci677DKGDRvGiBEj+OUvf0lMTAy/+93vKC0tJSUlhaFDh/K73/2uXnWccsopXHLJJYwfP55hw4Zx3nnnNcn7QESkrar3FEozCwX+BpwMpANLzGy+c+67gNN2A7cAMxpUZRBl1jD16FDHRUSamxkjEhoc2KqbNGkSf/zjHxk/fjxRUVFERERUWf8G0K1bNyZOnMjQoUM57bTTOP300xvluWfNmsXVV19NSkoKHTp04Nlna2n+0VylXNAogS1QcnIy33333UHH7733Xu69996Dji9atOigY5GRkTzxxBMHHZ8yZQpTpkwBvM6TV111FeB1pAxUMeIGcOutt3LrrbcewSsQEZG6spqmotTpB83GA7Occ9P99+8EcM4dtPjBzGYBBc65h+py7dGjR7u0tLR61dXYDrV+5Is7pgWhIhFp677//vvDTlUUae70PhYROTQzW+qcG139eEOmUCYAgSux0/3H6sXMZppZmpml7dq1qwFlNa6mWD8iIiIiIiJSHw3pQlnTxj31G84DnHOzgdngjcDV9zqNrWLa0YPvryMzt5D4mEhunz640acjiYi0Veeccw6bN2+ucuzPf/4z06dPD1JFIiIizVdDAlw6kBRwPxHIbFg5zVNTrB8REWkI51ytG2C3NG+88UawS5CjrL7LN0REpGFTKJcAA82sr5m1By4C5jdOWSIiUpuIiAhycnL0IVhaJOccOTk5REREBLsUEZEWqd4jcM65MjO7GXgfCAWecs6tMbMb/I8/bmY9gTSgM+Azs9uAY51zexuhdhGRNikxMZH09HSa03phkSMRERFRuaG7iIgcmXp3oWxKzakLpYiIiIiIyNHWFF0oRURERERE5ChSgBMREREREWkhFOBERERERERaiGa5Bs7MdgE/BruOGsQC2cEuQlotvb+kKen9JU1J7y9pSnp/SVNrru+xPs657tUPNssA11yZWVpNCwlFGoPeX9KU9P6SpqT3lzQlvb+kqbW095imUIqIiIiIiLQQCnAiIiIiIiIthALckZkd7AKkVdP7S5qS3l/SlPT+kqak95c0tRb1HtMaOBERERERkRZCI3AiIiIiIiIthAKciIiIiIhIC6EAVwdmdqqZrTOzDWZ2R7DrkdbDzJLM7BMz+97M1pjZrcGuSVofMws1s2Vm9lawa5HWx8xizOxVM1vr/2/Z+GDXJK2Hmf3S///H1Wb2oplFBLsmabnM7CkzyzKz1QHHuprZh2b2g/97l2DWWBcKcIdhZqHA34DTgGOBi83s2OBWJa1IGfAr59wxwE+AX+j9JU3gVuD7YBchrdZfgfecc0OA4ei9Jo3EzBKAW4DRzrmhQChwUXCrkhbuGeDUasfuAD52zg0EPvbfb9YU4A5vLLDBObfJOVcCvAScHeSapJVwzm13zn3rv52P98EnIbhVSWtiZonA6cA/g12LtD5m1hmYDDwJ4Jwrcc7lBrcqaWXaAZFm1g7oAGQGuR5pwZxzC4Hd1Q6fDTzrv/0sMOOoFlUPCnCHlwBsC7ifjj5gSxMws2RgBPBNcCuRVuYR4L8AX7ALkVapH7ALeNo/TfefZhYV7KKkdXDOZQAPAVuB7UCec+6D4FYlrVAP59x28P6wDsQFuZ7DUoA7PKvhmPZekEZlZh2B14DbnHN7g12PtA5mdgaQ5ZxbGuxapNVqB4wE/u6cGwHsowVMP5KWwb8W6WygLxAPRJnZZcGtSiT4FOAOLx1ICrifiIbvpRGZWRheeHveOfd6sOuRVmUicJaZbcGb/j3NzOYEtyRpZdKBdOdcxcyBV/ECnUhjOAnY7Jzb5ZwrBV4HJgS5Jml9dppZLwD/96wg13NYCnCHtwQYaGZ9zaw93uLZ+UGuSVoJMzO8tSPfO+f+J9j1SOvinLvTOZfonEvG+2/XAuec/notjcY5twPYZmaD/YdOBL4LYknSumwFfmJmHfz/vzwRNcmRxjcfuNJ/+0pgXhBrqZN2wS6guXPOlZnZzcD7eN2PnnLOrQlyWdJ6TAQuB1aZ2XL/sf92zr0TxJpERI7EfwDP+//IuQm4Osj1SCvhnPvGzF4FvsXr2rwMmB3cqqQlM7MXgSlArJmlA3cD9wMvm9m1eH80OD94FdaNOaflXCIiIiIiIi2BplCKiIiIiIi0EApwIiIiIiIiLYQCnIiIiIiISAuhACciIiIiItJCKMCJiIiIiIi0EApwIiLSaplZuZktD/i6oxGvnWxmqxvreiIiInWhfeBERKQ1K3TOpQa7CBERkcaiETgREWlzzGyLmf3ZzBb7vwb4j/cxs4/NbKX/e2//8R5m9oaZrfB/TfBfKtTM/mFma8zsAzOLDNqLEhGRNkEBTkREWrPIalMoLwx4bK9zbizwf8Aj/mP/BzznnEsBngce9R9/FPjMOTccGAms8R8fCPzNOXcckAv8rIlfj4iItHHmnAt2DSIiIk3CzAqccx1rOL4FmOac22RmYcAO51w3M8sGejnnSv3HtzvnYs1sF5DonCsOuEYy8KFzbqD//m+AMOfcvU3/ykREpK3SCJyIiLRVrpbbtZ1Tk+KA2+VobbmIiDQxBTgREWmrLgz4/pX/9pfARf7blwKL/Lc/Bm4EMLNQM+t8tIoUEREJpL8UiohIaxZpZssD7r/nnKvYSiDczL7B+2Pmxf5jtwBPmdntwC7gav/xW4HZZnYt3kjbjcD2Jq9eRESkGq2BExGRNse/Bm60cy472LWIiIgcCU2hFBERERERaSE0AiciIiIiItJCaARORESOCjNLNjNnZu389981syvrcm49nuu/zeyfDalXRESkOVKAExGROjGz983snhqOn21mO440bDnnTnPOPdsIdU0xs/Rq1/6Tc+7nDb22iIhIc6MAJyIidfUMcLmZWbXjlwPPO+fKjn5JbUt9RyRFRKT1UIATEZG6mgt0BSZVHDCzLsAZwHP++6eb2TIz22tm28xsVm0XM7NPzezn/tuhZvaQmWWb2Sbg9GrnXm1m35tZvpltMrPr/cejgHeBeDMr8H/Fm9ksM5sT8PNnmdkaM8v1P+8xAY9tMbNfm9lKM8szs3+bWUQtNfc3swVmluOv9Xkziwl4PMnMXjezXf5z/i/gsesCXsN3ZjbSf9yZ2YCA854xs3v9t6eYWbqZ/cbMdgBPm1kXM3vL/xx7/LcTA36+q5k9bWaZ/sfn+o+vNrMzA84L87+G1Nr+GYmISPOjACciInXinCsEXgauCDh8AbDWObfCf3+f//EYvBB2o5nNqMPlr8MLgiOA0cB51R7P8j/eGW9vtofNbKRzbh9wGpDpnOvo/8oM/EEzGwS8CNwGdAfeAd40s/bVXsepQF8gBbiqljoNuA+IB44BkoBZ/ucJBd4CfgSSgQTgJf9j5/vPu8L/Gs4CcurwewHoiRec+wAz8f7f/bT/fm+gEPi/gPP/BXQAjgPigIf9x58DLgs476fAdudc4D55IiLSzCnAiYjIkXgWON/MIv33r/AfA8A596lzbpVzzuecW4kXnE6ow3UvAB5xzm1zzu3GC0mVnHNvO+c2Os9nwAcEjAQexoXA2865D51zpcBDQCQwIeCcR51zmf7nfhOocVTKObfBf51i59wu4H8CXt9YvGB3u3Nun3OuyDm3yP/Yz4EHnHNL/K9hg3PuxzrW7wPu9j9noXMuxzn3mnNuv3MuH/hjRQ1m1gsv0N7gnNvjnCv1/74A5gA/NbPO/vuX44U9ERFpQRTgRESkzvyBZBdwtpn1A8YAL1Q8bmbjzOwT//S+POAGILYOl44HtgXcrxJuzOw0M/vazHabWS7e6FFdrltx7crrOed8/udKCDhnR8Dt/UDHmi5kZnFm9pKZZZjZXrxQVFFHEvBjLWsBk4CNday3ul3OuaKAGjqY2RNm9qO/hoVAjH8EMAnY7ZzbU/0i/pHJL4Cf+ad9ngY8X8+aREQkSBTgRETkSD2HN/J2OfCBc25nwGMvAPOBJOdcNPA43rTDw9mOFz4q9K64YWbhwGt4I2c9nHMxeNMgK657uA1NM/GmG1Zcz/zPlVGHuqq7z/98Kc65znhTEivq2Ab0rqXRyDagfy3X3I835bFCz2qPV399vwIGA+P8NUz2Hzf/83QNXJdXzbP+ms8HvnLO1ed3ICIiQaQAJyIiR+o54CS8dWvVtwHohDcCVGRmY4FL6njNl4FbzCzR3xjljoDH2gPheCN/ZWZ2GnBKwOM7gW5mFn2Ia59uZieaWRheACoGvqxjbYE6AQVArpklALcHPLYYL4jeb2ZRZhZhZhP9j/0T+LWZjTLPADOrCJXLgUv8jVxO5fBTTjvhrXvLNbOuwN0VDzjntuM1dXnM3+wkzMwmB/zsXGAkcCv+xjMiItKyKMCJiMgRcc5twQs/UXijbYFuAu4xs3zgLrzwVBf/AN4HVgDfAq8HPF8+cIv/WnvwQuH8gMfX4q212+TvMhlfrd51eKNO/wtkA2cCZzrnSupYW6Df4wWgPODtanWW+689ANgKpOOtv8M59wreWrUXgHwOdPQEL0ydCeQCl/ofO5RH8NbwZQNfA+9Ve/xyoBRYi9f85baAGgvxRjP7BtYuIiIthzl3uJknIiIi0lqY2V3AIOfcZYc9WUREmh1tCCoiItJG+KdcXos3SiciIi2QplCKiIi0AWZ2HV6Tk3edcwuDXY+IiNSPplCKiIiIiIi0EBqBExERERERaSGa5Rq42NhYl5ycHOwyREREREREgmLp0qXZzrnu1Y83ywCXnJxMWlpasMsQEREREREJCjP7sabjmkIpIiIiIiLSQijAiYiIiIiItBAKcCIiIiIiIi2EApyIiIiIiEgLoQAnIiIiIiLSQijAiYiIiIiItBDNchsBERERERGRpjR3WQYPvr+OzNxC4mMiuX36YGaMSAh2WYelACciIiIiIm3K3GUZ3Pn6KgpLywHIyC3kztdXATT7EKcplCIiIiIi0qb8+b21leGtQmFpOQ++vy5IFdWdRuBERERERKRNyMwt5MlFm9meV1Tr482dApyIiIiIiLRq63bk88TCjcxfnokDIsNCDxqBA4iPiTz6xR0hBTgREREREWl1nHN8s3k3T3y2kU/W7aJD+1CuGJ/MNccnk7ZlT5U1cOCFutunDw5ixXVTpwBnZqcCfwVCgX865+6v9vjZwB8AH1AG3OacW+R/bAuQD5QDZc650Y1WvYiIiIiISIByn+PD73bw+GebWL4tl25R7fnVyYO4fHwfYjq0ByCxSweAFtmF0pxzhz7BLBRYD5wMpANLgIudc98FnNMR2Oecc2aWArzsnBvif2wLMNo5l13XokaPHu3S0tKO9LWIiIiIiEgbVVRazuvfZvCPzzexOXsffbp14LpJ/ThvVCIRYaHBLu+ImdnSmga/6jICNxbY4Jzb5L/QS8DZQGWAc84VBJwfBRw6FYqIiIiIiDSCvP2lzPnmR57+YgvZBcUMS4jmb5eM5NShPQkNsWCX1+jqEuASgG0B99OBcdVPMrNzgPuAOOD0gIcc8IGZOeAJ59zsmp7EzGYCMwF69+5dp+JFRERERKRt2p5XyJOfb+bFxVvZV1LOCYO6c/0J/RjfrxtmrS+4VahLgKvp1R80wuacewN4w8wm462HO8n/0ETnXKaZxQEfmtla59zCGn5+NjAbvCmUdX0BIiIiEiQrX4aP74G8dIhOhBPvgpQLgl2ViLRy63bkM3vhJuYtz8ABZ6b0Yubk/hwb3znYpR0VdQlw6UBSwP1EILO2k51zC82sv5nFOueynXOZ/uNZZvYG3pTMgwKciIiItCArX4Y3b4FS/55Jedu8+6AQJyKNzjnH4s27eWLhJhaszSIyLJTLx/fh2uP7VjYkaSvqEuCWAAPNrC+QAVwEXBJ4gpkNADb6m5iMBNoDOWYWBYQ45/L9t08B7mnUVyAiIiJH38f3HAhvFUoLveMKcCLSSLyOkjt5YuFGlm3NpWtUe/7z5EFc/pM+dIlqH+zyguKwAc45V2ZmNwPv420j8JRzbo2Z3eB//HHgZ8AVZlYKFAIX+sNcD7xplRXP9YJz7r0mei0iIiJyNORleCNuNT62DXasgp7Djm5N0vpoim6bVlRazhvLMvjHwk1syt5H764d+MOMoZzfQjtKNqbDbiMQDNpGQEREpBkqzIUvHoGv/w5lRbWcZICD3hNg3EwYcgaEhh3NKqU1qD5FFyAsEs58VCGulcsrLOV5f0fJXfleR8nrT+jHaUN7tcqOkofSkG0EREREpC0rK4YlT8LCB6BwD6RcCL1SYcE9B3/Anv4nKC6AJf+AV66CTvEw5loYdRVExQbrFUhLoym6bc72vEKeWrSZF75rBf+EAAAgAElEQVTxOkpOHtSdv17Yj/H9W3dHyfpQgBMREZGa+Xyw+jUvqOVuhX5T4eTfQ6/h3uNRsbVPcRv/C1j/Pix+Ahb8AT57AIb+zBuVix8RvNcURHOXZfDg++vIzC0kPiaS26cPZsaIhGCX1fyUFR96iu5Ll0L3Id5X3BDoNhDCIo5ujdJo1u/M54nPDnSUPCOlF9e3oY6S9aEplCIiInKwTZ/Ch3fB9hXQY5gX3AacWL9r7VoHi2fD8hehdB8kjoVx18MxZ0G7ttGEYO6yDO58fRWFpeWVxyLDQrnv3GEKcQDOwfblsOx5WPUKFOXWfF67SIhJgpyN4Py/SwuBLn39oW4wxB3jfY8d5I0KS7PjnGPJlj088dlGPvZ3lLxwTBLXHt+XpK5tq6PkodQ2hVIBTkRERA7YsRo+uhs2fATRSTDtdzDsfAgJafi1i/K8D+hL/gG7N0HHnjD6ahh1NXTq0fDrNzM+n2NXQTHpewr5+bNL2LO/9KBzEmIi+eKOaUGorpnYlw0r/+29L7LWQGg4HHOG995b/ETta+DKSmD3Rsj63vsDwS7/95wN4Cvz/4BBl+QDga5i1C52ELRXSAgGn8/x4fc7eeKzjXzr7yh51YTkNt1R8lAU4ERERKR2udvgkz/BihchIhom/xrGXNc0U9N8Pi8gLn7C+x4SBsed443KJR70WaXZKiwpJyO3kEz/V4b/q+L2jrwiSssP/znrzZuPZ2hC57azzqe8FH74EJY/D+vf8wJXwihIvRSGnguRXbzz6tOFsqzE++NARaDbtRay1vqDXUWANujS50Cgq5iKGTsI2kc16Utvq4rLynnj2wxm+ztKJnWNZOakfpw3KonI9m27o+ShKMCJiIjIwQr3wKKH4evHvfvjrodJ/3ngQ3RTy97gjcgtex5K8iF+pFfDcedAu/CjU0MNnHNkF5TUGs4yc4vYva+kys+EGPTsHEF8TCTxMZEkdPF/j4ngjtdWkZVfXOvz9esexYzUBM5OjadPt1YaIrK+h2VzvGC2LwuiunsNcUZc5o2SNaXyUn+w8we6XWv9I3Y/QHnAP8eY3tD9mGpTMQdDeMemra+Vqt5RcmhCZ66f3J/ThvakXWgjjOo3VDPfqkIBTkRERA4oLfKC08KHvKmNwy+Cqb/11hcFQ3E+rHjJWyuXvd77cD/qKhh9DXSOb/SnKyotZ0deUdVgtqeQzDwvnGXkFlJS5qvyMx3ah5IQEM682xEkxHQgPiaCHp0jCKvlQ2lta+B+d8YxgDF3eQaLN+8GYETvGGakJnBGSi+6dQxeiG0Uhbmw+lUvoGd+CyHtYNCp3mjbwJODv8VEeRns2XzwVMzs9VWDXXRvb5SucirmMdB9EIR3Cl7tzdiOvCKe+sLrKFlQXMakgbHccEJ/JjSnjpItYKsKBTgRERHxpi+uegUW3At5W6H/iV6Dkuay8bZzsOkT+Ga2N70uJNRrdjLuekgaB3X48OecI3d/aY3hLCO3iIw9hWQXHDwaFtcpPGDULLIyrHkhLZLoyLAGffg8XBfKjNxC5i/PZN7yDNbuyCc0xJg0MJYZqQmcfGwPosJbSPNwX7nXBGf58/D9W1BeDD2GeqFt2PnQsXuwKzy88jLYs8U/UhcwHXPXeu/1VIhOqrq+rqKRSkTb7KD4w858nljodZT0OTh9WC+uP6Efx8VHH50CnPP+ILU/B/bt8tZY7s/2f692bOd3BxrhBIpOgl+uPjr1HoYCnIiISFu3cQF8eDfsWAk9U+Dke6D/1GBXVbvdm2HJP+Hbf0FxnlfzuOspPeYcduy3WsLZfjJzi6qMdAFEhIVUBrP46APTG+NjIkiM6UCP6HDC2zWftTjrduQzd3kG85dnkpFbSGRYKKcc14MZqQkcPzC21pG+oMrZCMtf8NZR7s2AiBhvJCP1Um/rieYy8tIQvvKAYBcwHTN7fdXN7TsnVF1fVxnsjlKQOYqcc6T96HWU/Oj7LCLCQrhoTO/G6SjpnNeRdF92tTCWXe2YP5ztzwlY61hN+47QoZu3/UlUd+8PRDUymFVLF9SjTAFORESkrdq+0ussuXGBt8Zn2l3enmyN0VmykTnn2FtUViWYZeXsJnHbm0zIfo3e5T+y23XkpfJpzCk7iUy8zcFjO7Y/ENBiqo+iRdA1qn3zmbp1BHw+78Px3OUZvL1yO3mFpXSNas/pw3oxY0Q8I3t3Ce7rKi6A7+Z6UyS3fum19O8/zQttg3/advZn85VD7o/eSF2V6ZjroSxgil6n+Krr6yrW20XGBK/2eqqpo+SV45O5fHwfutbWUdLnOxDIKkOYP3jVFMz25wR0Fa0mvPOBQNYhFqK6ecGsQ2wNx7odvKXEw0Nr3m9QI3D1owAnIiLSCHK3elMlV77sfUCcfDuM+XmjNQepz8bUZeU+svKLqzQEydhT0cnRW3tWUFz1A1v70BDiYyKIj45gUvu1nLR3Lv13L8QM9vc9lbAJN9C+/+TWMcJzCCVlPj5bv4u5yzP46LudFJf5SOoaydnDE5gxIp4BcUdpPZZz8OOX3hTJNXO9vf26DfBC2/CLmmTNYovl8x0IdhWjdhUNVEr3HzivY8+AkbqAkbuj1UzoCBSXlTN3WQZPLNzE5l35HNelnOtGdubUvmGEF+ccGBGrMaDl1DxtESA82gtcHfwjZJW3Yw98D7zd0P+OaQ1c41KAExERaYD9u+Hzv3gNQSwEfnIjTLytUf/KX1tTjrvPPJaRfbpUnd4YEM527C2i3Ff1s0eXDmE1jJpVTHOMIDYqnJCQauEsd6t/euVzXifNuONg3EwYdkGb2OMrv6iU99fsZN7yDL7YkI3PwXHxnZmRmsCZw+PpGd0EI1956d5m7Muf9xp/tO/otf1PvQySxrb6AN2ofD5v9Ccw0FWM3JXuO3Bexx5VR+rijvHCXYeuB1+zMToq+sq9f58qg9eB9WMle3eydds2crMz6VSeR1xoATFuL4av5mtFRFcbEQuYvlgxOlYR1jp0g3ZB2AdOXSgbjwKciIhIPZQWeXurff4XKNrrjYhMvdP7YNIIKjamzsgt5Npnat6Yurp2IUbP6IgagpnXXr9XdGTDmnOUFnpNWb6ZDTtXeeuuRl7ujTR2Sa7/dVuQrPwi3lqxnXnLM1iRnocZjO/XjRmpCZw6rCedIxrQ6bG0ENa+7bX/3/Qp4CB5kvfeOvYs7ZvW2Hw+2JtebSqmP+CV5B84Lyqu6lTMvdvhq79Vna4ZFgmnPwIDph26mUfl+rFs748/1JwNcl1HclwnyiK60a1HPN3iErDaRsc6dAt+h9FWQAFORESktfKVe39JXnCv9+Fv4Clw0izocdwRXaawpNxrBrLnwObU6bkHRtC25xXWaWPqRy8eQYK/vX73TuGEVh89awrOwdav4Jsn4Ps3wflg8Gle98q+J7SZ0aFNuwqY5+9kuSVnP+3bhXDikDjOTk1g6pDudWvU4hxkfAvL58Cq17wGMtG9IfUSSL24zQTjZsU5rzFM5R52FeFuHRTvrccFzZueGRUwAlYZwLzpi+nFUfz7u/28uraIHF8Up6b0ZubkfgxNaH2NWJorBTgREZHWxjnY8LHXoGTnaogf4XWW7Du5hlMbtjH1ga6NkSTGRPKb11bWuDF1QkwkX9wxrclecp3kZUDaU7D0GW9UofsQGHsdpFzUZjZkds6xIj2PucsyeGtlJtkFJXSOaMdPh/XirNR4ftK328HTUguyvL34lj/vhYR2EXDs2d5oW/KkZtn0ps1zDvZmwsPHUdvIGT996ODpi5FdILTmke+0Lbt5PKCj5IWjk/j5pH4N7ygpR0wBTkREpDXJXA4f3gWbP4OYPpRM/R2Z8aeSkVdc542po9qHVglm1fc+69k5gnZHuDH1fecOO2wjk6OmtAjWvO6Nym1f7jVJGHGpN72yW/9gV3fUlJX7+GJjDvOWZfD+mh3sKymnZ+cIzkqNZ8awWI7J/wpb/gL88IHXYCJxrPd7Ou6cVtn2vlVqYEdFn8/x0fc7eWLhJpb+uIcuHcK4ckIyV4xPrr2jpDQ5BTgREZEWyjnHnv2lZOYWsjtjPQnf/oX+O96lIKQzL0ZezJNFU9mxr2o4M/M2pg4cNase1DpHtmvSjambDecgfYkX5L6b6005HXgyjL3ea3nfhkaWCkvK+fD7nSz95nOSt73BWSGL6Gb57GsfS/mwi+j8kyuh+6BglylHqp4dFYvLypm3LJMnFm5k4659JHaJ5LpJ/bhgdBKR7ZvPvohtlQKciIhIM1VS5mPn3qKqLfXzCkkP6OAYXprLze3mcnnoh/gI4Vn3U97ufAExXWIPNAcJ+N4zOoL27dpOMKmz/B2Q9rQ3xXJfltf+fsx13vquiM7Brq5p7d8Nq1711rZtX4ELCWNr9ynMKT6ep3b0o5xQRvfpwtkjEjh9WC+NvLQ0R9BRcW9RKS98s5WnFm0mK7+YY3t15oYp/fnp0J61jrrL0acAJyIiEgQVG1MHBrOMPQfWn2XmFrEzv4jq/zuO7RhOQkwEfTqHMKN4PhN3/ov2ZfvZM/gCbOp/E9Ojd4vcmLrZKCuB7+bBN49DRprXEj/1Ehg7E2IHBru6xuMr9zZwXzYH1r0D5SXQMwVGXAbDzq9sR79t937mr/Can6zfWUC7EOOEQd05e0QCJx/TQ6MxrcTOvUU89cVmXvh6K/nFZRw/IJbrT+jH8QNi9d+TZkgBTkRE5DDquzH1zvziyjVnB4LZgeYgtW1MndAlkvjogGmN/vVovaIjiAgFVrwIn/zJ6z436FSvs2TcMU32+tusjKXeNgRrXvcCTv9p3vTKgae03OmV2Ru8kbYVL0H+dojsCikXemvbeg6r9cecc3y/PZ95yzOYvyKT7XlFRLUPZfpxPTl7RAIT+3fTCE0LtCErn9kLN/HGsgzKfY7TU+K5Xh0lmz0FOBERkUM47MbUe6p3bfTCWW0bUweGs8RqjUK6RbU/uANgBefghw+9zpJZ30H8SDjlD5B8fFO+fAEo2OV1rkx70gs9XZK96ZUjLmvUTdCbTNFeWPOG10Vy2zdgod5av9RLvT8AHOFGyT6f45vNu5m3PIN3Vm1nb1EZsR3bc0ZKPGenxpOaFKNRm2akpj9AJXWN5O+fbuKj73cSERbCBaOT+Pnx/ejdTR0lWwIFOBERkWp8PkdWvte18efP1n1j6l4xEcRHeyNm1defxcdE0KF9PTemzvjW6yy55XPo0hdOuhuOndFm9jBrNspLvb3kFs/29pYL6wDDL/KmVza3EVCfD35cBMueh+/nQ+l+iB3sjbSlXAidejbK0xSXlfPJ2l3MW57Bx2uzKCnzkdytA2elJjAjNZ5+3dvG9gzNVU1/gAox8DmI6RDGleOTuWJ8H7p1DA9ilXKkFOBERKTN2V9SVtlCv8r+Z/72+jvyiuq0MfX/XjyiMqQ1ycbUuzfDgj/A6te8/ZpOuANGXXXEIybSBLav8KZXrnoFyou9PfbGXu9tEh4SxHVhe370ptgufwFyf4TwzjD0Z95oYcKoJg39e4tKeW/VDuatyODLjTk4BymJ0ZydmsCZw3sR1ymiyZ5bPGXlPnYVFLM9r4ideUXc8fpK8grLDjovOrIdX915Yv3/qCRBpQAnIiKtis/nyNlXUiWcpVdrFFJ9RC00xPwbU0cc1LUxKBtT78uBhQ/AkichNAzG/wIm3NL6uyG2RPty4NtnvX9We9MhujeMuRZGXlHZCKTJlez3RgaXz4HNCwGDfidA6mVwzBle2/ijbOfeIt5ckcnc5RmszthLiMHEAbGcnZrA9ON60Cki7KjX1NLtKy5jx14vmO3YW+SFtL1F7PDf35FXRHZBMb46fIQ3YPP9pzd5zdI0FOBERKRFKSotZ3te0UHNQSoDW17RITemDgxnFcd6dApvHhtTl+yHrx+DL/4KJQVeCJhyZ6NNd5MmVF7mdXNcPNub6touwuvmOO76QzYHqbeKPeyWzfHWtxXv9dbmpV4Kwy+GmKTGf8562pCVz7zlXpjbtruQ8HYhnHRsD2akJnDCoO5tflsLn8+xe3+JF8T+f3t3Hh9Vfe9//PXNvoclBEgCBGTfEUQRQUEFAZFo/Vm9Wpda9723WG2v1bYuiLa21ipa69LbVi91CSAoKq64AiaGJYDsJGFJAgmQPZnv748zkMkCCZDkZJL38/HIY2a+c86cz+AI885384ax2sFs94FSDpbW15MWTLeYMLrGhtEtJpRuseF0iwmjW2wo3WLCuf7VFewqLK1zXrP+AkqanQKciIi0Goc3pq5/1cYSsguc3zD7OrwxdZ1gdngVx47hxIS18o2pPVXOAhMfP+oskjFghjPPrcuApruGtJw9a50g9/3/QWUJ9BrvzJMbeCEEnuSQtQO7ION1Z4hk3kZnHt7gFGduW88zW/XqmNZavttRwIL0bN7J2MW+onI6RAQzfVh3UkYmMqZXx6Mv4uOnyiqr2Hug7EgQ2+PtOfPtSdtzoO6Q7QAD8dFOMOseE0a32DC6+gSzbrFhdIsJa3Abhxb9BZS0GAU4ERFpMeWVHnYXltbpNcv2uV9aUbP3LCw4oGY461C9cmNSx3C6xvjxxtTWwsal8OFDkJsJSafB+b+HXuPcrkyaQvE+p4dsxd+gYAfEJMKYnzrzGCPjGv86lWWw4V0n5G/6EKwHeo5zetuGpEBodLO9heZSUeVh+Q95pKZn8/7aPZRUVJHYIZyZIxJIGZXAwG6te7jw4X0cj/SUHe4t8wazw8Mb84vK65wbHhxI9yOBzLn1fdwtJoy4qJAm25ah2X8BJS1OAU5EpD3KmA/LfgeFWRCbBOf+BoZfdlIvaa3lQElljTCWU1BCls/9vQfLjroxtW+vme8S+x0jgtvmkuRZq+CDB2D7F9DpFKfHbdBFWlmyLfJUOUH92+dhyycQGOosLHL6jZAw6uj/P+763llFcvV8KNkP0Qkw8gonuHU+xe131WSKyir5YN0eUtOz+fyHPKo8loHdopk1MpFZIxNI6NCyc/iqPJa8Q2Xs9gliu32C2uHHxeVVdc7tHBlSHcS8YezwEMfDIe1kRwSIKMCJiLQ3GfOpXHAHQVXV8yIqA8MImvWXY4a4yioPuw+UklNQWqfX7PB8tKJaX2jq3ZjaZ4n97rFhhAW7uGKfG/I3O1/W16VCZBc45z449RpnsRJp+3I3OMMr01+DiiInvBfudDYKPywgGKK6OouiBIbCwBnOEMk+k9xd4bIF5B0qY3HGLhakZ/PdjgIAxvbuRMrIRKYP60aHiJCT6lEqKa+qMZxxd+0etMJScg+V1dnDMTjQEB9dN5j5Po6PCSU0qG3/95HWQQFORNoEDRFpvOLHBxJRsqtue2g8O6/5lpwDFTV6zbK9KzjuPlBaZ3Wzk9qYur05lOusLLnyJedL+Zl3wJm3++XwN2kCpYVO79oHD4Cn7uIUBAbD1Mdg2KUQ3rHl62sFduQXsyA9m9T0bDbnFhEcaBjQNZoNew7WmDMWHhzIoxcP5ewB8UedZ3Y4oBWW1N3TMTo06EgQ6+obzHwCWqcI/V0mrYcCnIj4vZaYpG2txWOdoTUea6nyWKqsxePxvU89bc5tlaf6+RqvUfvYI88d/bWq26j1+rWvSY3rhJflMqjgE2ZmPXXUUXpV1rCbTuTYzuyycRwI7UZpRAI2NongTr2IjE8mvksXbw/aSWxM3Z6UF8FX3pUlK4ph9DXOfm7RXd2uTFqDhzoA9X3nMvBQQUtX0ypZa1mbc4DUtGxe+mJro5bJB2c0cpeo0LrzzGr1nEWG6u8x8S9HC3D6JIuI35i7dH2N8AZQUlHF7De+5+Uvt9UKRrXDEPWGrapa5zT2C0NrERhgCDSGbgH7mGq+ZXrAN4xiPQFYKggkmLpzN/bbKHIH/oROVXsZXrqLMUU5mMIVcKACDgA7vQeGxjpLlMcmeX961LyN7tbmh3k1SlWlsy/Xx4/Bod3OCoTnPQRx/dyuTFqT2CRnCGV97QKAMYahibEMTYzl78u3HvW431w42Alp3mDWJTqU4CZaCETEHyjAiUirZq0lbWcBC9KyySmou8cNQEWVpUN4MIEBhgBjCAzA574TcAJ8bwOo0RYYUOt572vUeL7WcYEBVL++77XqfU3qtNU8p/q16n3Nw69Ru+3QLli30JljteNrwEKXQTDkPhicwiMvvMa9Fc8SYarn3BTbEP4c/DMeuuK3Nf8QPR44tMdZXKFwp/cny/kp2Om8fmmtXoKAIIhJ8AY6n6DXwedxSGQTfyJaEWudFQM/fAjyNkCP0+GyV6HnGW5XJq3Rub+BRXdCRUl1W3C40y51JHQIJ7ugpE57YodwfnpWbxcqEmk9FOBEpFXanHuIBWnZLPg+h+35xYQEBRAWHFBn6Xlw/kF/9adjXajSBYXZkLkQ1qbCzq+dtvjBzibQQ1Jq7Cc2csaN/ObtSu62r5Ng8smxnfkTl3PWjBvrvm5AAMR0d356nFb/tcsOOtf3DXgF3tvtX8KBbLC1evzCO1X32tXpzevhLO7RivezOqqdK5w5TTu+gs794Mf/chag0IpzcjSHFw5q4lVh26rZUwfUO2R+9lTtmSiiOXAi0mrsPVDKwu9zWJCew+rsQgIMnHlKHBeNTOCCod34KHNv+9yotDAL1i1wQlvWt05b16HOpr6DZ0GX/kc9tUUXfamqdIYQHgl2Pr14hTudtvKDNc8JDHH2zPLttatxm+j0UrQWeZtg2W+dEB0ZD5Puh1FXn/ymzSJShxatkvZOi5iISKt0sLSC99bsZkF6Dl9uzsNjYVhiLLNGJnDRiATiY8JqHN9u/kEv2OmEtnWpkLXCaes6DIbMgsEXQ1xfd+s7UaWF1b12tYdqFmbBwV3O5sW+Irv49Nz1rDtUM6Jz8/d8HdoLnz4OK1+GoDAYfxeMuw1Co5r3uiIi0m6dVIAzxlwA/BkIBF601s6p9fws4PeAB6gE7rbWLm/MufVRgBNp28oqq/h0Qy4L0nP4MHMPZZUeenaKIGVkAheNTKRvfDv9Urx/e3Voy17ltHUb7gyNHJzSpjb0PaqqCjiQUzfg+Ya+iuKa5wSF+wS8JOjQs+bjmCQICmnc9WtvtHz2vU49X/4FKkth9LVw9i8hKr7J37qIiIivEw5wxphAYCNwPpAFrACusNau8zkmCiiy1lpjzHBgvrV2YGPOrY8CnEjb4/FYvt22jwXp2SxZvZvCkgo6R4Zw4fDuzBqVyKgeHTDtcf7Q/m3VwyNzvnPauo+oHh7ZHkLb8bAWSvbXWmRlR82hmof21DrJOJslH+m185mDdzjkhXeE1f+pu8jEYYNnwbkP6r+HiIi0mJPZRmAssMlau8X7Qq8Ds4AjIcxae8jn+EiqNzpp8FwRadsydx0gNT2bRek55BSWEhESyJTBXZk1KpGz+sa1z6Wf922t7mnLSXPaEkbBeb+FwRdBpz7u1teaGQMRnZyf7iPqP6ayzFlQpcB3eKY35O1e7awcWVlrRdOQKKetvo2WI+Phsn80/XsRERE5AY0JcIlU7woETk/a6bUPMsZcDDwGxAMzjudc7/k3AjcC9OzZsxFliUhrlV1QwoL0bBak5bBhz0ECAwwT+8Xxy2kDOX9w1/a5KfS+LU4v27pU2PW905ZwKpz/O6d3p2Oyq+W1KUGhTgg+WhC2ForyfHrxvLdfP1v/8UW5zVeriIjIcWrMt6j6xjTVGXdprX0beNsYMxFnPtx5jT3Xe/4LwAvgDKFsRF0i0ooUFJezePUuFqTl8O22fQCM7tWR388awvRh3ekcFepyhS7I3+wEtrWpsDvDaUscDef/3hvaerlbX3tlDER1cX4ST61uz1ykjZZFRKTVa0yAywJ6+DxOAnKOdrC19jNjzCnGmLjjPVdE/EtJeRUfZu5hQXoOn27cS0WVpW98FL+Y0p9ZIxPp0SnC7RJbXt4mWPc2rF0Ae1Y7bUmnwZRHnOGRHTTCoNXSRssiIuIHGhPgVgD9jDG9gWzgcuC/fA8wxvQFNnsXMTkVCAHygYKGzhUR/1JZ5eHLzfmkpmezdM1uisqr6BoTyrVnJjNrZCJDEmLa32IkeT9UD4/cs8ZpSxoLUx+FQRc5C2dI66eNlkVExA80GOCstZXGmNuBpThbAbxkrV1rjLnZ+/w84EfA1caYCqAE+LF1lres99xmei8i0kystWRkFTqLkXy/i7xDZUSHBjFjeHdSRiZyep/OBAa0s9CWu7F6eORe719rPc6AC+Y4oS22De5N1x4Mv0yBTUREWjVt5C0iR7Utr4jU9GwWpOewNa+IkMAAJg3sQsrIRCYNjCcsONDtElvW3vXVoS03EzDQ8wzvkv8XQUyC2xWKiIhIG3Ey2wiISDuSe7CMdzJySE3P4fudBRgDp/fuxE0T+zBtaHdiI4LdLrFl7c2sHh6Zux4ntI2DaXOdnraY7m5XKCIiIu2IApyIcKiskqVrdpOans0Xm/LwWBjcPYZfTR/IzBEJdI8Nd7vElmMt7F3nDW0LIG8DYKDXeJj+JAyaCdHd3K5SRERE2ikFOJF2qrzSw2cbc0lNz+bDzD2UVnhI6hjOLeecQsrIRPp1jXa7xJZjLexZWz08Mv8HMAFOaBt7g9PTFt3V7SpFREREFOBE2hOPx7Jqx35S07JZvHoXBcUVdIwI5tLRSaSMTGR0r47tZwVJa2H3aqeXbV0q5G9yQlvyWXDGLU5PW1S821WKiIiI1KAAJ9IObNxzkNQ0ZzGS7IISwoIDOH9wN1JGJjChXxdCggLcLrFlWOtsqH14Ttu+Ld7QNgHG3QYDZzqbO4uIiIi0UgpwIm1UTkEJi753FiPJ3HWAAANn9evCf0/pz5Qh3YgKbSf/+1sLu76vHh65fyuYQOg9Ec680+lpi4xzu0oRERGRRmkn3+BE2ofC4gqWrNlFalo2327bh7UwokcHHpw5mAuHJ9AlOtTtEluGtZCT5oS2dQtg/5L9UOcAACAASURBVDYntPU5G866BwZeCJGd3a5SRERE5LgpwIn4udKKKj5av5fUtGw+2ZBLeZWHPnGR3H1uf2aNTCA5LtLtEptWxnxY9jsozILYJDj3N87Gy9ZCznfVq0cWbIeAIOh9Nkz4bye0RXRyu3oRERGRk6IAJ+KHqjyWr7fkk5qWzXtrdnOwrJIu0aFcdUYvUkYlMCwxtm0uRpIxHxbdCRUlzuPCnbDgdlj9H2ePtoIdTmjrMwnOvhcGTFdoExERkTZFAU7ET1hrWZtzgNS0bBZl5LDnQBlRoUFMHdKNlFEJjOvTmaDANrgYibVQfghKD8D7D1SHt8OqyuCH96HfFDj7Phg4HcI7ulOriIiISDNTgBNp5XbkF5Oans2C9Gw25xYRHGg4u388D1yYwHmDuhIWHOh2iUdnLVQUO+Gr7ID3thBKC2u1eW9LC2sddwDKDoKtauBCBq78T4u8JRERERE3KcCJuCw1LZsnlm4gp6CEhA7hzJ46gAn94ngnYxep6dmk7SgAYGxyJ356Vm+mD+1Ox8iQ5i/MWqgs9QlYhbUCVn2hq57HnspjX8cEQGgMhMVAaKxzG5sEYYO97d620Bj46PdQnF/3NWKTmufPQERERKSVUYATcVFqWjbL336W/+N1EkLzyCmO48k3LuOeqrOwwICu0dx7wQAuGpFAUseI43vxyjKfnq76erwK6w9dvvc9FQ1cxPiEL+9tTAKEDqzZdiSIxdY9PiQKGjtfLySy5hw4gOBwZyETERERkXZAAU6khVlr2XuwjG15RXyzYB6/My8QYcoBSDJ5PGpeJDwIrrvmRvrHepwwtX8F7K4dunyCWX09Y1VlDRcTEl0zYEXFQ+e+NQNWWGx1z1jtQBYSBQEtOO9u+GXObX2rUIqIiIi0A8Za63YNdYwZM8auXLnS7TJETpjH44S0rXlFbM8vYlt+MdvyitiWX8T2/GJKKpw5XV+F3Eb3gP0ndpHgyJrDC+uErph6erx8jg+NhoBWPH9OREREpB0zxqyy1o6p3a4eOJET5PFYdh8oPRLKDge0bXnFbN9XRGmF58ixwYGGHp0iSO4cyYWJJYyr+JZ++R8Tk19/eLOAmTa3bug6Er5iIFD/+4qIiIi0N/oGKHIMHo9l14FStucVsdUb1A73qm3PL6assjqkhQQG0KNTOL3jIjmrXxzJcZEkd44guVMECWWbCdzwDmQugm3rnBMSRlEeFE1I5cE61y0J707E6Te11NsUERERET+hACftXpXHsquwhG15xd7etCK25hU7IW1fMeW+IS0ogF6dIujVOZKz+3ehV+dIkjtHkhwXQffYcAIDvItxeDyQvRIyF8KSRbB/m7PaYs9xcMEcGDgDOvQkJGM+lQvuIKiq9Mg1KgPDiJj2uxb+UxARERERf6AAJ+1ClceSU1DiHeLozElzgloRO/eVUF5VHdJCgwLo1TmC3nGRTBoY79zvHEmvuEi6x4QREHCUFROrKmDzcqeXbf1iOLQbAoKhzzlw1s9hwHSI6lLznOGXOf8T+izKEaRFOURERETkKBTgpM2orPKQU+DMSTs8F+3w/Z37iqmoql6wJyw4gOTOkfSNj+K8QV1JjoukV2dnjlq3Y4W02ipKYPNHkPkObFgCpQUQHAF9z4NBF0H/Kc4ctmMZfpkCm4iIiIg0igKc+JXKKg/ZBSXeeWg156Pt3F8zpIUHB9KrcwT946OZMribMx8tzhnyGB8d2viQVlvpAfjhfWd45A8fQkWRE9IGTIdBM+GUyc7eZCIiIiIiTUwBTlqdiioPWfurhztuzy8+cj9rfwmVnuqQFhESSK/OkQzsHs3Uod2coY7eoBYfHYpp7AbRDSnKc3rYMhfBlk+gqhyiusKIHzuhLXkCBAY3zbVERERERI5CAU6aXGpaNk8s3UBOQQkJHcKZPXUAKaMSaxxTXukha39x9bL7+UVs9c5Ly9pfQpVPSIsMCSQ5LpIhCbHMGN69xsIhXaKaMKTVVpjlDI3MXAQ7vgTrgQ69YOyNzvDIpNNadhNrEREREWn3tJG3NKnUtGzuf2v1kY2qwVlef/qwbkSHBR+Zk5a9vwSfjEZUaBDJcc4ctGRvL1rvuEh6dY4kLiqk+UJabXk/OIEtcxHkfOe0xQ+GgRc6PW3dhkFL1SIiIiIi7ZY28pYW8cTSDTXCG0B5lYfU9Byiw4LoHRfJyB4dSRmZeKQXLblzJJ0iWzCk+bIWdmdUh7bc9U574mg47yEYOBPi+rZ8XSIiIiIi9VCAkyaVU1BSb7sBMh6c4k5Iq83jgaxvvaFtIRTscPZo6zUexvzU2aMtNsntKkVERERE6lCAkybVNSaU3QfK6rQndAh3N7xVlsO2z6v3aCvaC4Eh0GcSTLwXBkyDyDj36hMRERERaQQFOGlSPTpG1Alw4cGBzJ46oOWLKS/27tG2CDa+C6WFEBzp7M028ELoNwXCYlq+LhERERGRE6QAJ01mTXYhK3fsZ/LALmzYfeiYq1A2m5KCmnu0VZZAeMfqRUj6nKM92kRERETEbynASZOw1vLI4kw6RoTwp8tHERPWgnuiHdrrDItc/w5s+RQ8FRDdHUZd6YS2XuO1R5uIiIiItAkKcNIkPszcy1db8vn9rCEtE94Kdvjs0fYVYKFjbzjjFmePtsTR2qNNRERERNocBTg5aRVVHh5bkskpXSK5YmzP5rtQ7obq5f53pTttXYfCOfc5QyS7DtEebSIiIiLSpinAyUn79zc72JJXxN+vGUNQYBP2elnrBLXDoS1vo9OedBqc/zsntHU+pemuJyIiIiLSyinAyUkpLKngTx9u5MxTOjN5YPzJv6CnCnZ87cxny1wEhTvBBELyWTD2RmePtpiEk7+OiIiIiIgfUoCTk/Lsx5soKKng1zMGnfg+b5XlsPUzZ+XI9YuhOA8CQ+GUyXDO/c4ebRGdmrZwERERERE/pAAnJ2znvmJe/mIbl56axJCE2OM7ubwINi3z7tH2HpQdgJAo6D/Vu0fb+RAa3TyFi4iIiIj4qUYFOGPMBcCfgUDgRWvtnFrPXwn80vvwEHCLtfZ773PbgINAFVBprR3TNKWL2+a8t57AAMMvam/SnTEflv0OCrMgNgnO/Q0MvwxK9sPGpU5o27TMu0dbJxh8kbNyZO+zITjMnTcjIiIiIuIHGgxwxphA4K/A+UAWsMIYs9Bau87nsK3A2dba/caYacALwOk+z0+y1uY1Yd3islXb97M4Yxd3nduPrjE+oStjPiy6EypKnMeFO2HBrbD8KWcREk8lRCfAqVc7e7T1HAeB6ggWEREREWmMxnxzHgtsstZuATDGvA7MAo4EOGvtlz7Hfw0kNWWR0rpYa3l48Trio0O56ew+NZ9c9rvq8HZYVYUT3sbd7vS0JYzSHm0iIiIiIiegMd+iE4GdPo+zvG1Hcz3wrs9jC7xvjFlljLnxaCcZY240xqw0xqzMzc1tRFnilsWrd5G2o4BfTBlAREit3wEUZtV/kqcKzv8tJGmDbRERERGRE9WYHrj6lha09R5ozCScAHeWT/N4a22OMSYe+MAYs95a+1mdF7T2BZyhl4wZM6be1xf3lVZUMefd9QzqHsOPRtfT0RrdDQ7uqtseq05ZEREREZGT1ZiukCygh8/jJCCn9kHGmOHAi8Asa23+4XZrbY73di/wNs6QTPFTr365jaz9JfzPjEEEBtTK9lWVEFTPIiTB4c5CJiIiIiIiclIaE+BWAP2MMb2NMSHA5cBC3wOMMT2Bt4CfWGs3+rRHGmOiD98HpgBrmqp4aVn7isp55uNNTB4Yz/i+cXUP+OwJ2L8VTvsZxPYAjHM782lnFUoRERERETkpDQ6htNZWGmNuB5bibCPwkrV2rTHmZu/z84DfAJ2BZ72bOR/eLqAr8La3LQj4t7X2vWZ5J9Ls/vzhRorLq/jV9IF1n9zxDXw2F4ZfDjP+4PyIiIiIiEiTatT67dbaJcCSWm3zfO7/DPhZPedtAUacZI3SCmzOPcS/vtnBFWN70De+1gbbpQfgrRuc3rbpT7hToIiIiIhIO6ANuKRRHluynvDgQO4+r3/dJ9+919nv7bp3ISym5YsTEREREWkntJ67NOjLzXl8mLmHWyf1JS4qtOaTa96E71+DibOh5xnuFCgiIiIi0k4owMkxeTyWRxZnktghnOvGJ9d8smAnvHMPJJ0GE+91pT4RERERkfZEAU6O6a20bNbmHODeCwYQFhxY/YSnCt6+2bm95AUI1GhcEREREZHmpm/dclQl5VU8uXQDI3p04KIRCTWf/OLPsH05zHoWOvVxp0ARERERkXZGPXByVH/7fAu7D5TywIxBeLeCcOSkwcePwOAUGPlf7hUoIiIiItLOKMBJvfYeKGXep5uZPqwbY5I7VT9RXgRv/gyiusKFT4FvsBMRERERkWalIZRSrz+8v5GKKg+/vKDWpt1LfwX5m+GahRDRqf6TRURERESkWagHTurI3HWA+at2cs24ZHp1jqx+Yv1iWPUKjL8Tek90rT4RERERkfZKAU5qsNby6JJMYsODuWNyv+onDu6GBbdD9xEw6X/cK1BEREREpB1TgJMaPtmYy+c/5HHn5H7ERgQ7jR4PpN4CFSVwyYsQFOJukSIiIiIi7ZTmwMkRlVUeHlmcSe+4SK46o1f1E9/Mg80fwYw/Qpf+7hUoIiIiItLOqQdOjnh9xU427T3EfdMGEhLk/WjsXgMfPgj9p8GYn7pboIiIiIhIO6cAJwAcLK3gqQ82MrZ3J6YM7uo0VpTAWzdAWAeY9Yy2DBARERERcZmGUAoAz32ymfyicl723bT7w4dg7zq48k2IjHO1PhERERERUQ+cAFn7i3lx+VYuHpXI8KQOTuMPHzpz306/Gfqd526BIiIiIiICKMAJ8MTSDRhg9tQBTkNRnrPqZPxgOO+3rtYmIiIiIiLVFODaufSdBSxIz+GGCX1I6BAO1jr7vZUWwCV/g+Awt0sUEREREREvzYFrx6y1PLJ4HXFRodx8zilO46qXYeO7MPUx6DbU3QJFRERERKQG9cC1Y0vX7mbFtv38/Pz+RIUGQe5GeO9XcMpkZ+6biIiIiIi0Kgpw7VR5pYc5766nf9coLhuTBJXl8Ob1EBwOKc9BgD4aIiIiIiKtjb6lt1P/+/V2tuUX86vpgwgKDICPH4bdGXDRXyC6m9vliYiIiIhIPRTg2qGC4nKeXvYDE/t34ZwB8bD1M/jiaRh9LQy60O3yRERERETkKBTg2qGnl23iYGkFv54+CIr3wVs3QedTYOqjbpcmIiIiIiLHoFUo25lteUX879fb+PFpPRjQNQr+cy0U7YXLP4CQSLfLExERERGRY1APXDsz5931hAQGcM/5/eH712BdKkz6NSSe6nZpIiIiIiLSAAW4duTbrft4b+1ubj77FOIrcmDJbOh1Foy/y+3SRERERESkETSEsp3weCwPL15H99gwfja+J/xzBphAuHgeBAS6XZ6IiIiIiDSCeuDaiYXf55CRVcjsqQMI/+qPkLUCZj4FHXq4XZqIiIiIiDSSAlw7UFpRxdz31jMsMZaUzlnw2VwYcQUM/ZHbpYmIiIiIyHHQEMp24O/Lt5JTWMqfLz6FgLdnQmwPmDbX7bJEREREROQ4KcC1cbkHy3juk82cP7grp617DAqz4Lr3ICzG7dJEREREROQ4aQhlG/fUhxspraji4b4bION1mHgv9Dzd7bJEREREROQEKMC1YRv3HOT1b3dw26mhdP30fkg6DSbOdrssERERERE5QQpwbdijSzKJCQ3g9oInwFbBJS9AoEbNioiIiIj4K32bb6M+/yGXTzbkMn/wVwRv+QpSnoNOfdwuS0RERERETkKjeuCMMRcYYzYYYzYZY+6r5/krjTEZ3p8vjTEjGnuuNL0qj+WRxZmcH5vDadueg8EpzrYBIiIiIiLi1xoMcMaYQOCvwDRgMHCFMWZwrcO2Amdba4cDvwdeOI5zpYn9Z+VOtu/O5angZzBRXeHCp8AYt8sSEREREZGT1JgeuLHAJmvtFmttOfA6MMv3AGvtl9ba/d6HXwNJjT1XmlZRWSV/+GAjf+74HyIPbYeL50FEJ7fLEhERERGRJtCYAJcI7PR5nOVtO5rrgXeP91xjzI3GmJXGmJW5ubmNKEvq8/ynmxlVtJwpJe9ixt8FvSe6XZKIiIiIiDSRxixiUt/YO1vvgcZMwglwZx3vudbaF/AOvRwzZky9x8ix7SosIfXzlSwJ/zvEj4BJv3a7JBERERERaUKNCXBZQA+fx0lATu2DjDHDgReBadba/OM5V5rGH95bz6PmOSJMOVzyIgSFuF2SiIiIiIg0ocYMoVwB9DPG9DbGhACXAwt9DzDG9ATeAn5ird14POdK01iTXUhMxt85K2A1ARc8Bl36u12SiIiIiIg0sQZ74Ky1lcaY24GlQCDwkrV2rTHmZu/z84DfAJ2BZ42z2mGltXbM0c5tpvfSbllr+UfqOzwc/BoVfS8gePR1bpckIiIiIiLNwFjb+qabjRkzxq5cudLtMvzGsoztJL0xnZ5hJYTf9S1ExrldkoiIiIiInARjzCpr7Zja7Y3ayFtar4oqDwWLfsWAgCxCfjRP4U1EREREpA1TgPNzn77zb35U8Q47+11N4IApbpcjIiIiIiLNSAHOjx3Iy2Fk2q/YEZRM0mVz3S5HRERERESamQKcv7KW3f+8gWhbTHnKC5jgcLcrEhERERGRZqYA56f2fTaP/gXLea/7zfQderrb5YiIiIiISAtQgPNHuRuI+uRBltvhnHHFr9yuRkREREREWogCnL+pLKf4tes45Alm3djH6Rob4XZFIiIiIiLSQhTg/Iz96GEi9q3l0aDbuOr8sW6XIyIiIiIiLUgBzp9s+RS+fJp/V05m7AU/ISIkyO2KRERERESkBSnA+Yvifdi3b2Kn6c78uFv50egktysSEREREZEWpgDnD6yFd+7GcyiXW0tvZfaFowgMMG5XJSIiIiIiLUwBzh+k/xvWLeAv9jLiB5zB+L5xblckIiIiIiIu0CSq1m7fFnj3XrZGjeKv+2bw7vSBblckIiIiIiIuUQ9ca1ZVAW/eQJUJ5Cf7rufHY3vRNz7a7apERERERMQlCnCt2WdPQPZK/hZzB4XB8dx9Xn+3KxIRERERERcpwLVWO76Gz55gb5+LmbNzMLdO6ktcVKjbVYmIiIiIiIs0B641Ki2Et27Axvbg1v1XkNghmOvGJ7tdlYiIiIiIuEw9cK3RknuhMJuPhzzKyl2V3HvBAMKCA92uSkREREREXKYeuNZm9RuQ8ToVZ93L/d+GMaJHOBeNSHC7KhERERERaQXUA9eaFOyAd34OSafxnL2EPQfKeGDGIIzRpt0iIiIiIqIA13p4quDtm8FWkTflGeZ9vp3pw7oxJrmT25WJiIiIiEgroSGUrcUXf4LtX0DKczzxbTkVVR5+eYE27RYRERERkWrqgWsNsr+Djx+FIReTGT+D+at2cs24ZHp1jnS7MhERERERaUUU4NxWXgRv/gyiumJnPMUjS9YTGx7MHZP7uV2ZiIiIiIi0Mgpwbnvvfti3BS5+nk92VLB8Ux53Tu5HbESw25WJiIiIiEgrowDnpsxF8N2rMP4uKnuO55ElmfSOi+SqM3q5XZmIiIiIiLRCCnBuObALFt4B3UfApF/z+oqdbNp7iPumDSQkSP9ZRERERESkLiUFN3g8kHoLVJTCj/7OwUrDUx9sZGzvTkwZ3NXt6kREREREpJXSNgJu+OY52PIxXPgUxPXjuffWk19UzsvatFtERERERI5BPXAtbfdq+PAhGDAdRl9H1v5iXly+lYtHJTI8qYPb1YmIiIiISCumANeSKkrgzRsgvCNc9BcwhieWbsAAs6cOcLs6ERERERFp5RTgWtIHD0JuJqQ8C5FxpO8sYEF6DjdM6ENCh3C3qxMRERERkVZOAa6l/PABfPs8nH4L9D0Pay2PLF5HXFQoN59zitvViYiIiIiIH1CAawmHciH1VogfDOc9BMDStbtZsW0/Pz+/P1GhWktGREREREQapuTQ3KyFhbdDaSFcnQrBYZRXenjs3fX07xrFZWOS3K5QRERERET8hHrgmtvKv8PG9+D830LXIQD846ttbM8v5tczBhMUqP8EIiIiIiLSOI1KD8aYC4wxG4wxm4wx99Xz/EBjzFfGmDJjzC9qPbfNGLPaGJNujFnZVIX7hdwNsPTXcMq5MPYmAAqKy/nLR5uY2L8LZ/fv4nKBIiIiIiLiTxocQmmMCQT+CpwPZAErjDELrbXrfA7bB9wJpBzlZSZZa/NOtli/UlkGb14PIZHOqpMBTlZ+etkmDpZW8Ovpg1wuUERERERE/E1jeuDGApustVusteXA68As3wOstXuttSuAimao0T999LCzafdFz0B0NwC25hXxv19v48en9WBAt2iXCxQREREREX/TmACXCOz0eZzlbWssC7xvjFlljLnxaAcZY240xqw0xqzMzc09jpdvhbZ8Cl/+BUZfBwOnH2me824mIYEB3HN+fxeLExERERERf9WYAGfqabPHcY3x1tpTgWnAbcaYifUdZK19wVo7xlo7pksXP54bVrwP3r4ZOveFqY8caf5mSz5L1+7h5rNPIT46zMUCRURERETEXzUmwGUBPXweJwE5jb2AtTbHe7sXeBtnSGbbZC0suguK9sKP/ubMfwM8HssjSzLpHhvGzyb0cblIERERERHxV40JcCuAfsaY3saYEOByYGFjXtwYE2mMiT58H5gCrDnRYlu99H9B5kKY/D+QMOpI88Lvc8jIKmT21AGEhwS6WKCIiIiIiPizBlehtNZWGmNuB5YCgcBL1tq1xpibvc/PM8Z0A1YCMYDHGHM3MBiIA942xhy+1r+tte81z1txWf5mePeXkDwBzrzzSHNpRRVz31vPsMRYUkYez9RBERERERGRmhoMcADW2iXAklpt83zu78YZWlnbAWDEyRToF6oq4K0bISAQLp7n3Hr9fflWcgpL+eOPRxIQUN90QhERERERkcZpVICTBnw6F7JXwqUvQ2x1js09WMazH2/i/MFdOaNPZxcLFBERERGRtqAxc+DkWLZ/BZ8/CSP+C4ZeUuOppz7cSFmlh/unDXSpOBERERERaUsU4E5GaSG8fSN06AnTHq/x1MY9B3n92x1cdUYv+nSJcqlAERERERFpSzSE8mQsmQ2F2fDT9yAspsZTjy7JJCo0iLvO7edScSIiIiIi0taoB+5ErX4DMv4Pzr4XetTc2u6zjbl8siGXOyb3o2NkiEsFioiIiIhIW6MAdyIKdsA7P4eksTDhFzWeqvJYHl2SSc9OEVx9Zi+XChQRERERkbZIAe54eargrZvAeuCSFyCw5ijU/6zcyfrdB7lv2kBCg7Rpt4iIiIiINB3NgTtey5+CHV9Cyjzo1LvGU0Vllfzhg42M6dWRaUO7uVSgiIiIiIi0VQpwjZExH5b9DgqzAAuJY2DE5XUOe/7TzeQeLOOFn4zGGG3aLSIiIiIiTUtDKBuSMR8W3QmFOwHrtO1ZC6v/U+OwXYUlvPD5FmaOSGBUz44tX6eIiIiIiLR5CnANWfY7qCip2VZZ4rT7eGLpBjwW7p06oAWLExERERGR9kQBriGFWQ22r8ku5K3vsrlufDI9OkW0UGEiIiIiItLeKMA1JDbpmO3WWh5evI5OkSHcNqlvCxYmIiIiIiLtjRYxaci5v3HmwPkOowwOd9qBDzP38vWWffx+1hBiwoJdKlJE2pOKigqysrIoLS11uxSRExIWFkZSUhLBwfp3U0TkeCnANWT4Zc7t4VUoY5Oc8Db8MiqqPDy2JJNTukRyxdie7tYpIu1GVlYW0dHRJCcna8Vb8TvWWvLz88nKyqJ3794NnyAiIjUowDXG8Muqg5yPf329nS15Rfz9mjEEBWo0qoi0jNLSUoU38VvGGDp37kxubq7bpYiI+CWljhNUWFLBn5f9wJmndGbywHi3yxGRdkbhTfyZPr8iIidOAe4E/fXjTRSUVPDrGYP0D5GIiIiIiLQIBbgTsHNfMa98sY1LT01iSEKs2+WIiBxTalo24+d8RO/7FjN+zkekpmW7XVL7ljEfnhoKD3VwbjPmn/RLbtu2jaFDhzZBcXV98sknXHjhhQAsXLiQOXPmNMt1RESkcRTgTsCc99YTGGD4hTbtFpFWLjUtm/vfWk12QQkWyC4o4f63VjdriJs+fToFBQUUFBTw7LPPHmn3DQLtVsZ8Z2Xjwp2AdW4X3dkkIa4lXHTRRdx3331ulyEi0q5pEZPjtGr7PhZn7OKuc/vRNSbM7XJEpJ377aK1rMs5cNTn03YUUF7lqdFWUlHFvW9k8Nq3O+o9Z3BCDA/OHHLCNS1ZsgRweoWeffZZbr311hN+rRNVWVlJUJAL/8S9ex/sXn3057NWQFVZzbaKElhwO6x6tf5zug2DaQ33elVWVnLNNdeQlpZG//79+cc//sGTTz7JokWLKCkp4cwzz+T555/HGMPTTz/NvHnzCAoKYvDgwbz++usUFRVxxx13sHr1aiorK3nooYeYNWtWjWu88sorrFy5kmeeeYZrr72WmJgYVq5cye7du5k7dy6XXnopAE888QTz58+nrKyMiy++mN/+9rcN1i8iIo2jHrjj4GzanUl8dCg3nd3H7XJERBpUO7w11N4Yc+fO5emnnwbgnnvuYfLkyQAsW7aMq666iuTkZPLy8rjvvvvYvHkzI0eOZPbs2QAcOnSISy+9lIEDB3LllVdirT3qdZKTk3nwwQc59dRTGTZsGOvXrwdg3759pKSkMHz4cM444wwyMjIAeOihh7jxxhuZMmUKV199Na+88gopKSnMnDmT3r1788wzz/DHP/6RUaNGccYZZ7Bv374T/jM4YbXDW0Ptx2HDhg3ceOONZGRkEBMTw7PPPsvtt9/OihUrWLNmDSUlJbzzzjsAvvs0KgAAC7ZJREFUzJkzh7S0NDIyMpg3bx4AjzzyCJMnT2bFihV8/PHHzJ49m6KiomNec9euXSxfvpx33nnnSM/c+++/zw8//MC3335Leno6q1at4rPPPjvp9yciIg71wB2HdzJ2kbajgLk/Gk5EiP7oRMR9DfWUjZ/zEdkFJXXaEzuE8383jTuha06cOJE//OEP3HnnnaxcuZKysjIqKipYvnw5EyZMYPny5YATEtasWUN6ejrgDKFMS0tj7dq1JCQkMH78eL744gvOOuuso14rLi6O7777jmeffZYnn3ySF198kQcffJBRo0aRmprKRx99xNVXX33kGqtWrWL58uWEh4fzyiuvsGbNGtLS0igtLaVv3748/vjjpKWlcc899/CPf/yDu++++4T+DI6qoZ6yp4Z6h0/WEtsDrlt8Upfu0aMH48ePB+Cqq67i6aefpnfv3sydO5fi4mL27dvHkCFDmDlzJsOHD+fKK68kJSWFlJQUwAleCxcu5MknnwSc7Sp27Ki/l/awlJQUAgICGDx4MHv27DnyOu+//z6jRo0CnND+ww8/MHHixJN6fyIi4lAPXCOkpmVz5mPLuOO1NIICDEEBWnVSRPzD7KkDCA8OrNEWHhzI7JOYwzt69GhWrVrFwYMHCQ0NZdy4caxcuZLPP/+cCRMmHPPcsWPHkpSUREBAACNHjmTbtm3HPP6SSy45cs3Dxy5fvpyf/OQnAEyePJn8/HwKCwsBZ45WeHj4kfMnTZpEdHQ0Xbp0ITY2lpkzZwIwbNiwBq/dLM79DQSH12wLDnfaT1LtFZGNMdx666288cYbrF69mhtuuIHS0lIAFi9ezG233caqVasYPXo0lZWVWGt58803SU9PJz09nR07djBo0KBjXjM0NPTI/cO9qdZa7r///iOvs2nTJq6//vqTfn8iIuJQgGvA4QUAcgqdf/QqPZZfp67RKm4i4hdSRiXy2CXDSOwQjsHpeXvskmGkjEo84dcMDg4mOTmZl19+mTPPPJMJEybw8ccfs3nz5uP6wh8YGEhlZWWjjvc9tr5hl4fDS2Rk5FGvFxAQcORxQEBAg9duFsMvg5lPOz1uGOd25tNO+0nasWMHX331FQCvvfbakZ7NuLg4Dh06xBtvvAGAx+Nh586dTJo0iblz51JQUMChQ4eYOnUqf/nLX478+aalpZ1QHVOnTuWll17i0KFDAGRnZ7N3796TfXsiIuKlcYANeGLpBkoqqmq0lVRU8cTSDSf1BUhEpKWkjEps8r+vJk6cyJNPPslLL73EsGHD+PnPf87o0aNr9AJFR0dz8ODBJr3u4Wv/61//4oEHHuCTTz4hLi6OmJiYJr9Osxl+WZMEttoGDRrEq6++yk033US/fv245ZZb2L9/P8OGDSM5OZnTTjsNgKqqKq666ioKCwux1nLPPffQoUMHHnjgAe6++26GDx+OtZbk5OQjc+aOx5QpU8jMzGTcOGeIblRUFP/85z+Jj49v0vcrItJeKcA1IKeeuSPHahcRaQ8mTJjAI488wrhx44iMjCQsLKzO8MnOnTszfvx4hg4dyrRp05gxY0aTXPuhhx7iuuuuY/jw4URERPDqq0dZvbEdSU5OZt26dXXaH374YR5++OE67YfnKfoKDw/n+eefr9N+zjnncM455wBw7bXXcu211wLOipS+Dve4Adx1113cddddx/EORESkscyxVgBzy5gxY+zKlSvdLgM49gIAX9w32YWKRKS9y8zMbHCookhrp8+xiMixGWNWWWvH1G7XHLgGNMcCACIiIiIiIidCQygbcHjeyBNLN5BTUEJCh3BmTx2g+W8iIk3k4osvZuvWrTXaHn/8caZOnepSRSIiIq2XAlwjNMcCACIiJ8NaW2fZeH/19ttvu12CtLDWOH1DRMRfaAiliIifCQsLIz8/X1+CxS9Za8nPzycsLMztUkRE/JJ64ERE/ExSUhJZWVnk5ua6XYrICQkLCyMpKcntMkRE/JICnIiInwkODqZ3795ulyEiIiIu0BBKERERERERP6EAJyIiIiIi4icU4ERERERERPyEaY2rmBljcoHtbtdRjzggz+0ipM3S50uakz5f0pz0+ZLmpM+XNLfW+hnrZa3tUruxVQa41soYs9JaO8btOqRt0udLmpM+X9Kc9PmS5qTPlzQ3f/uMaQiliIiIiIiIn1CAExERERER8RMKcMfnBbcLkDZNny9pTvp8SXPS50uakz5f0tz86jOmOXAiIiIiIiJ+Qj1wIiIiIiIifkIBTkRERERExE8owDWCMeYCY8wGY8wmY8x9btcjbYcxpocx5mNjTKYxZq0x5i63a5K2xxgTaIxJM8a843Yt0vYYYzoYY94wxqz3/l02zu2apO0wxtzj/fdxjTHmNWNMmNs1if8yxrxkjNlrjFnj09bJGPOBMeYH721HN2tsDAW4BhhjAoG/AtOAwcAVxpjB7lYlbUgl8N/W2kHAGcBt+nxJM7gLyHS7CGmz/gy8Z60dCIxAnzVpIsaYROBOYIy1digQCFzublXi514BLqjVdh+wzFrbD1jmfdyqKcA1bCywyVq7xVpbDrwOzHK5JmkjrLW7rLXfee8fxPnik+huVdKWGGOSgBnAi27XIm2PMSYGmAj8HcBaW26tLXC3KmljgoBwY0wQEAHkuFyP+DFr7WfAvlrNs4BXvfdfBVJatKgToADXsERgp8/jLPQFW5qBMSYZGAV8424l0sb8CbgX8LhdiLRJfYBc4GXvMN0XjTGRbhclbYO1Nht4EtgB7AIKrbXvu1uVtEFdrbW7wPnFOhDvcj0NUoBrmKmnTXsvSJMyxkQBbwJ3W2sPuF2PtA3GmAuBvdbaVW7XIm1WEHAq8Jy1dhRQhB8MPxL/4J2LNAvoDSQAkcaYq9ytSsR9CnANywJ6+DxOQt330oSMMcE44e1f1tq33K5H2pTxwEXGmG04w78nG2P+6W5J0sZkAVnW2sMjB97ACXQiTeE8YKu1NtdaWwG8BZzpck3S9uwxxnQH8N7udbmeBinANWwF0M8Y09sYE4IzeXahyzVJG2GMMThzRzKttX90ux5pW6y191trk6y1yTh/d31krdVvr6XJWGt3AzuNMQO8TecC61wsSdqWHcAZxpgI77+X56JFcqTpLQSu8d6/BljgYi2NEuR2Aa2dtbbSGHM7sBRn9aOXrLVrXS5L2o7xwE+A1caYdG/br6y1S1ysSUTkeNwB/Mv7S84twHUu1yNthLX2G2PMG8B3OKs2pwEvuFuV+DNjzGvAOUCcMSYLeBCYA8w3xlyP80uD/+dehY1jrNV0LhEREREREX+gIZQiIiIiIiJ+QgFORERERETETyjAiYiIiIiI+AkFOBERERERET+hACciIiIiIuInFOBERKTNMsZUGWPSfX7ua8LXTjbGrGmq1xMREWkM7QMnIiJtWYm1dqTbRYiIiDQV9cCJiEi7Y4zZZox53Bjzrfenr7e9lzFmmTEmw3vb09ve1RjztjHme+/Pmd6XCjTG/M0Ys9YY874xJty1NyUiIu2CApyIiLRl4bWGUP7Y57kD1tqxwDPAn7xtzwD/sNYOB/4FPO1tfxr41Fo7AjgVWOtt7wf81Vo7BCgAftTM70dERNo5Y611uwYREZFmYYw5ZK2Nqqd9GzDZWrvFGBMM7LbWdjbG5AHdrbUV3vZd1to4Y0wukGStLfN5jWTgA2ttP+/jXwLB1tqHm/+diYhIe6UeOBERaa/sUe4f7Zj6lPncr0Jzy0VEpJkpwImISHv1Y5/br7z3vwQu996/Eljuvb8MuAXAGBNojIlpqSJFRER86TeFIiLSloUbY9J9Hr9nrT28lUCoMeYbnF9mXuFtuxN4yRgzG8gFrvO23wW8YIy5Hqen7RZgV7NXLyIiUovmwImISLvjnQM3xlqb53YtIiIix0NDKEVERERERPyEeuBERERERET8hHrgRERERERE/IQCnIiIiIiIiJ9QgBMREREREfETCnAiIiIiIiJ+QgFORERERETET/x/I/50h2G7kU0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_training_history(title, label, baseline, bn_solvers, plot_fn, bl_marker='.', bn_marker='.', labels=None):\n",
    "    \"\"\"utility function for plotting training history\"\"\"\n",
    "    plt.title(title)\n",
    "    plt.xlabel(label)\n",
    "    bn_plots = [plot_fn(bn_solver) for bn_solver in bn_solvers]\n",
    "    bl_plot = plot_fn(baseline)\n",
    "    num_bn = len(bn_plots)\n",
    "    for i in range(num_bn):\n",
    "        label='with_norm'\n",
    "        if labels is not None:\n",
    "            label += str(labels[i])\n",
    "        plt.plot(bn_plots[i], bn_marker, label=label)\n",
    "    label='baseline'\n",
    "    if labels is not None:\n",
    "        label += str(labels[0])\n",
    "    plt.plot(bl_plot, bl_marker, label=label)\n",
    "    plt.legend(loc='lower center', ncol=num_bn+1) \n",
    "\n",
    "    \n",
    "plt.subplot(3, 1, 1)\n",
    "plot_training_history('Training loss','Iteration', solver, [bn_solver], \\\n",
    "                      lambda x: x.loss_history, bl_marker='o', bn_marker='o')\n",
    "plt.subplot(3, 1, 2)\n",
    "plot_training_history('Training accuracy','Epoch', solver, [bn_solver], \\\n",
    "                      lambda x: x.train_acc_history, bl_marker='-o', bn_marker='-o')\n",
    "plt.subplot(3, 1, 3)\n",
    "plot_training_history('Validation accuracy','Epoch', solver, [bn_solver], \\\n",
    "                      lambda x: x.val_acc_history, bl_marker='-o', bn_marker='-o')\n",
    "\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batch normalization and initialization\n",
    "We will now run a small experiment to study the interaction of batch normalization and weight initialization.\n",
    "\n",
    "The first cell will train 8-layer networks both with and without batch normalization using different scales for weight initialization. The second layer will plot training accuracy, validation set accuracy, and training loss as a function of the weight initialization scale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "tags": [
     "pdf-ignore-input"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running weight scale 1 / 20\n",
      "Running weight scale 2 / 20\n",
      "Running weight scale 3 / 20\n",
      "Running weight scale 4 / 20\n",
      "Running weight scale 5 / 20\n",
      "Running weight scale 6 / 20\n",
      "Running weight scale 7 / 20\n",
      "Running weight scale 8 / 20\n",
      "Running weight scale 9 / 20\n",
      "Running weight scale 10 / 20\n",
      "Running weight scale 11 / 20\n",
      "Running weight scale 12 / 20\n",
      "Running weight scale 13 / 20\n",
      "Running weight scale 14 / 20\n",
      "Running weight scale 15 / 20\n",
      "Running weight scale 16 / 20\n",
      "Running weight scale 17 / 20\n",
      "Running weight scale 18 / 20\n",
      "Running weight scale 19 / 20\n",
      "Running weight scale 20 / 20\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "# Try training a very deep net with batchnorm\n",
    "hidden_dims = [50, 50, 50, 50, 50, 50, 50]\n",
    "num_train = 1000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "bn_solvers_ws = {}\n",
    "solvers_ws = {}\n",
    "weight_scales = np.logspace(-4, 0, num=20)\n",
    "for i, weight_scale in enumerate(weight_scales):\n",
    "  print('Running weight scale %d / %d' % (i + 1, len(weight_scales)))\n",
    "  bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization='batchnorm')\n",
    "  model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n",
    "\n",
    "  bn_solver = Solver(bn_model, small_data,\n",
    "                  num_epochs=10, batch_size=50,\n",
    "                  update_rule='adam',\n",
    "                  optim_config={\n",
    "                    'learning_rate': 1e-3,\n",
    "                  },\n",
    "                  verbose=False, print_every=200)\n",
    "  bn_solver.train()\n",
    "  bn_solvers_ws[weight_scale] = bn_solver\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=10, batch_size=50,\n",
    "                  update_rule='adam',\n",
    "                  optim_config={\n",
    "                    'learning_rate': 1e-3,\n",
    "                  },\n",
    "                  verbose=False, print_every=200)\n",
    "  solver.train()\n",
    "  solvers_ws[weight_scale] = solver"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": [
     "pdf-ignore-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot results of weight scale experiment\n",
    "best_train_accs, bn_best_train_accs = [], []\n",
    "best_val_accs, bn_best_val_accs = [], []\n",
    "final_train_loss, bn_final_train_loss = [], []\n",
    "\n",
    "for ws in weight_scales:\n",
    "  best_train_accs.append(max(solvers_ws[ws].train_acc_history))\n",
    "  bn_best_train_accs.append(max(bn_solvers_ws[ws].train_acc_history))\n",
    "  \n",
    "  best_val_accs.append(max(solvers_ws[ws].val_acc_history))\n",
    "  bn_best_val_accs.append(max(bn_solvers_ws[ws].val_acc_history))\n",
    "  \n",
    "  final_train_loss.append(np.mean(solvers_ws[ws].loss_history[-100:]))\n",
    "  bn_final_train_loss.append(np.mean(bn_solvers_ws[ws].loss_history[-100:]))\n",
    "  \n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Best val accuracy vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Best val accuracy')\n",
    "plt.semilogx(weight_scales, best_val_accs, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_best_val_accs, '-o', label='batchnorm')\n",
    "plt.legend(ncol=2, loc='lower right')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Best train accuracy vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Best training accuracy')\n",
    "plt.semilogx(weight_scales, best_train_accs, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_best_train_accs, '-o', label='batchnorm')\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Final training loss vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Final training loss')\n",
    "plt.semilogx(weight_scales, final_train_loss, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_final_train_loss, '-o', label='batchnorm')\n",
    "plt.legend()\n",
    "plt.gca().set_ylim(1.0, 3.5)\n",
    "\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 1:\n",
    "Describe the results of this experiment. How does the scale of weight initialization affect models with/without batch normalization differently, and why?\n",
    "\n",
    "## Answer:\n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batch normalization and batch size\n",
    "We will now run a small experiment to study the interaction of batch normalization and batch size.\n",
    "\n",
    "The first cell will train 6-layer networks both with and without batch normalization using different batch sizes. The second layer will plot training accuracy and validation set accuracy over time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "tags": [
     "pdf-ignore-input"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No normalization: batch size =  5\n",
      "Normalization: batch size =  5\n",
      "Normalization: batch size =  10\n",
      "Normalization: batch size =  50\n"
     ]
    }
   ],
   "source": [
    "def run_batchsize_experiments(normalization_mode):\n",
    "    np.random.seed(231)\n",
    "    # Try training a very deep net with batchnorm\n",
    "    hidden_dims = [100, 100, 100, 100, 100]\n",
    "    num_train = 1000\n",
    "    small_data = {\n",
    "      'X_train': data['X_train'][:num_train],\n",
    "      'y_train': data['y_train'][:num_train],\n",
    "      'X_val': data['X_val'],\n",
    "      'y_val': data['y_val'],\n",
    "    }\n",
    "    n_epochs=10\n",
    "    weight_scale = 2e-2\n",
    "    batch_sizes = [5,10,50]\n",
    "    lr = 10**(-3.5)\n",
    "    solver_bsize = batch_sizes[0]\n",
    "\n",
    "    print('No normalization: batch size = ',solver_bsize)\n",
    "    model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n",
    "    solver = Solver(model, small_data,\n",
    "                    num_epochs=n_epochs, batch_size=solver_bsize,\n",
    "                    update_rule='adam',\n",
    "                    optim_config={\n",
    "                      'learning_rate': lr,\n",
    "                    },\n",
    "                    verbose=False)\n",
    "    solver.train()\n",
    "    \n",
    "    bn_solvers = []\n",
    "    for i in range(len(batch_sizes)):\n",
    "        b_size=batch_sizes[i]\n",
    "        print('Normalization: batch size = ',b_size)\n",
    "        bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=normalization_mode)\n",
    "        bn_solver = Solver(bn_model, small_data,\n",
    "                        num_epochs=n_epochs, batch_size=b_size,\n",
    "                        update_rule='adam',\n",
    "                        optim_config={\n",
    "                          'learning_rate': lr,\n",
    "                        },\n",
    "                        verbose=False)\n",
    "        bn_solver.train()\n",
    "        bn_solvers.append(bn_solver)\n",
    "        \n",
    "    return bn_solvers, solver, batch_sizes\n",
    "\n",
    "batch_sizes = [5,10,50]\n",
    "bn_solvers_bsize, solver_bsize, batch_sizes = run_batchsize_experiments('batchnorm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplot(2, 1, 1)\n",
    "plot_training_history('Training accuracy (Batch Normalization)','Epoch', solver_bsize, bn_solvers_bsize, \\\n",
    "                      lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
    "plt.subplot(2, 1, 2)\n",
    "plot_training_history('Validation accuracy (Batch Normalization)','Epoch', solver_bsize, bn_solvers_bsize, \\\n",
    "                      lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
    "\n",
    "plt.gcf().set_size_inches(15, 10)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 2:\n",
    "Describe the results of this experiment. What does this imply about the relationship between batch normalization and batch size? Why is this relationship observed?\n",
    "\n",
    "## Answer:\n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Layer Normalization\n",
    "Batch normalization has proved to be effective in making networks easier to train, but the dependency on batch size makes it less useful in complex networks which have a cap on the input batch size due to hardware limitations. \n",
    "\n",
    "Several alternatives to batch normalization have been proposed to mitigate this problem; one such technique is Layer Normalization [2]. Instead of normalizing over the batch, we normalize over the features. In other words, when using Layer Normalization, each feature vector corresponding to a single datapoint is normalized based on the sum of all terms within that feature vector.\n",
    "\n",
    "[2] [Ba, Jimmy Lei, Jamie Ryan Kiros, and Geoffrey E. Hinton. \"Layer Normalization.\" stat 1050 (2016): 21.](https://arxiv.org/pdf/1607.06450.pdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 3:\n",
    "Which of these data preprocessing steps is analogous to batch normalization, and which is analogous to layer normalization?\n",
    "\n",
    "1. Scaling each image in the dataset, so that the RGB channels for each row of pixels within an image sums up to 1.\n",
    "2. Scaling each image in the dataset, so that the RGB channels for all pixels within an image sums up to 1.  \n",
    "3. Subtracting the mean image of the dataset from each image in the dataset.\n",
    "4. Setting all RGB values to either 0 or 1 depending on a given threshold.\n",
    "\n",
    "## Answer:\n",
    "BatchNorm: 3;\n",
    "LayerNorm: 1,2,4\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Layer Normalization: Implementation\n",
    "\n",
    "Now you'll implement layer normalization. This step should be relatively straightforward, as conceptually the implementation is almost identical to that of batch normalization. One significant difference though is that for layer normalization, we do not keep track of the moving moments, and the testing phase is identical to the training phase, where the mean and variance are directly calculated per datapoint.\n",
    "\n",
    "Here's what you need to do:\n",
    "\n",
    "* In `cs231n/layers.py`, implement the forward pass for layer normalization in the function `layernorm_backward`. \n",
    "\n",
    "Run the cell below to check your results.\n",
    "* In `cs231n/layers.py`, implement the backward pass for layer normalization in the function `layernorm_backward`. \n",
    "\n",
    "Run the second cell below to check your results.\n",
    "* Modify `cs231n/classifiers/fc_net.py` to add layer normalization to the `FullyConnectedNet`. When the `normalization` flag is set to `\"layernorm\"` in the constructor, you should insert a layer normalization layer before each ReLU nonlinearity. \n",
    "\n",
    "Run the third cell below to run the batch size experiment on layer normalization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before layer normalization:\n",
      "  means:  [-59.06673243 -47.60782686 -43.31137368 -26.40991744]\n",
      "  stds:   [10.07429373 28.39478981 35.28360729  4.01831507]\n",
      "\n",
      "After layer normalization (gamma=1, beta=0)\n",
      "  means:  [ 4.81096644e-16 -7.40148683e-17  2.22044605e-16 -5.92118946e-16]\n",
      "  stds:   [0.99999995 0.99999999 1.         0.99999969]\n",
      "\n",
      "After layer normalization (gamma= [3. 3. 3.] , beta= [5. 5. 5.] )\n",
      "  means:  [5. 5. 5. 5.]\n",
      "  stds:   [2.99999985 2.99999998 2.99999999 2.99999907]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Check the training-time forward pass by checking means and variances\n",
    "# of features both before and after layer normalization   \n",
    "\n",
    "# Simulate the forward pass for a two-layer network\n",
    "np.random.seed(231)\n",
    "N, D1, D2, D3 =4, 50, 60, 3\n",
    "X = np.random.randn(N, D1)\n",
    "W1 = np.random.randn(D1, D2)\n",
    "W2 = np.random.randn(D2, D3)\n",
    "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "\n",
    "print('Before layer normalization:')\n",
    "print_mean_std(a,axis=1)\n",
    "\n",
    "gamma = np.ones(D3)\n",
    "beta = np.zeros(D3)\n",
    "# Means should be close to zero and stds close to one\n",
    "print('After layer normalization (gamma=1, beta=0)')\n",
    "a_norm, _ = layernorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print_mean_std(a_norm,axis=1)\n",
    "\n",
    "gamma = np.asarray([3.0,3.0,3.0])\n",
    "beta = np.asarray([5.0,5.0,5.0])\n",
    "# Now means should be close to beta and stds close to gamma\n",
    "print('After layer normalization (gamma=', gamma, ', beta=', beta, ')')\n",
    "a_norm, _ = layernorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print_mean_std(a_norm,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx error:  1.4336157856136745e-09\n",
      "dgamma error:  4.519489546032799e-12\n",
      "dbeta error:  2.276445013433725e-12\n"
     ]
    }
   ],
   "source": [
    "# Gradient check batchnorm backward pass\n",
    "np.random.seed(231)\n",
    "N, D = 4, 5\n",
    "x = 5 * np.random.randn(N, D) + 12\n",
    "gamma = np.random.randn(D)\n",
    "beta = np.random.randn(D)\n",
    "dout = np.random.randn(N, D)\n",
    "\n",
    "ln_param = {}\n",
    "fx = lambda x: layernorm_forward(x, gamma, beta, ln_param)[0]\n",
    "fg = lambda a: layernorm_forward(x, a, beta, ln_param)[0]\n",
    "fb = lambda b: layernorm_forward(x, gamma, b, ln_param)[0]\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(fx, x, dout)\n",
    "da_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\n",
    "db_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n",
    "\n",
    "_, cache = layernorm_forward(x, gamma, beta, ln_param)\n",
    "dx, dgamma, dbeta = layernorm_backward(dout, cache)\n",
    "\n",
    "#You should expect to see relative errors between 1e-12 and 1e-8\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dgamma error: ', rel_error(da_num, dgamma))\n",
    "print('dbeta error: ', rel_error(db_num, dbeta))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Layer Normalization and batch size\n",
    "\n",
    "We will now run the previous batch size experiment with layer normalization instead of batch normalization. Compared to the previous experiment, you should see a markedly smaller influence of batch size on the training history!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No normalization: batch size =  5\n",
      "Normalization: batch size =  5\n",
      "Normalization: batch size =  10\n",
      "Normalization: batch size =  50\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ln_solvers_bsize, solver_bsize, batch_sizes = run_batchsize_experiments('layernorm')\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plot_training_history('Training accuracy (Layer Normalization)','Epoch', solver_bsize, ln_solvers_bsize, \\\n",
    "                      lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
    "plt.subplot(2, 1, 2)\n",
    "plot_training_history('Validation accuracy (Layer Normalization)','Epoch', solver_bsize, ln_solvers_bsize, \\\n",
    "                      lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
    "\n",
    "plt.gcf().set_size_inches(15, 10)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 4:\n",
    "When is layer normalization likely to not work well, and why?\n",
    "\n",
    "1. Using it in a very deep network\n",
    "2. Having a very small dimension of features\n",
    "3. Having a high regularization term\n",
    "\n",
    "\n",
    "## Answer:\n",
    "[2]\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
